marvin 2.3.2__tar.gz → 2.3.4__tar.gz

{marvin-2.3.2 → marvin-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: marvin
-Version: 2.3.2
+Version: 2.3.4
 Summary: A lightweight AI engineering toolkit for building natural language interfaces that are reliable, scalable, and easy to trust.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -249,7 +249,6 @@ Requires-Dist: pre-commit<4.0,>=2.21; extra == "dev"
 Requires-Dist: pydantic[dotenv]; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Provides-Extra: tests
-Requires-Dist: flaky; extra == "tests"
 Requires-Dist: pytest-asyncio!=0.22.0,<0.23.0,>=0.18.2; extra == "tests"
 Requires-Dist: pytest-env<2.0,>=0.8; extra == "tests"
 Requires-Dist: pytest-rerunfailures<14,>=10; extra == "tests"
@@ -508,13 +507,13 @@ marvin.paint("a simple cup of coffee, still warm")
 
 Learn more about image generation [here](https://askmarvin.ai/docs/images/generation).
 
-## 🔍 Classify images (beta)
+## 🔍 Converting images to data
 
-In addition to text, Marvin has beta support for captioning, classifying, transforming, and extracting entities from images using the GPT-4 vision model:
+In addition to text, Marvin has support for captioning, classifying, transforming, and extracting entities from images using the GPT-4 vision model:
 
 ```python
-marvin.beta.classify(
-    marvin.beta.Image("docs/images/coffee.png"),
+marvin.classify(
+    marvin.Image.from_path("docs/images/coffee.png"),
     labels=["drink", "food"],
 )
 

{marvin-2.3.2 → marvin-2.3.4}/README.md

@@ -236,13 +236,13 @@ marvin.paint("a simple cup of coffee, still warm")
 
 Learn more about image generation [here](https://askmarvin.ai/docs/images/generation).
 
-## 🔍 Classify images (beta)
+## 🔍 Converting images to data
 
-In addition to text, Marvin has beta support for captioning, classifying, transforming, and extracting entities from images using the GPT-4 vision model:
+In addition to text, Marvin has support for captioning, classifying, transforming, and extracting entities from images using the GPT-4 vision model:
 
 ```python
-marvin.beta.classify(
-    marvin.beta.Image("docs/images/coffee.png"),
+marvin.classify(
+    marvin.Image.from_path("docs/images/coffee.png"),
     labels=["drink", "food"],
 )
 

{marvin-2.3.2 → marvin-2.3.4}/cookbook/_archive/docs_writer.py

@@ -7,7 +7,7 @@ import marvin.tools.filesystem as fs
 from marvin.beta.applications import Application
 
 # marvin.settings.log_level = "DEBUG"
-marvin.settings.openai.chat.completions.model = "gpt-4-1106-preview"
+marvin.settings.openai.chat.completions.model = "gpt-4o"
 
 
 ROOT_DIR = Path(marvin.__file__).parents[2]

{marvin-2.3.2 → marvin-2.3.4}/cookbook/_archive/test_writing_application.py

@@ -9,7 +9,7 @@ from marvin.beta.applications import Application
 from pydantic import BaseModel, Field
 
 marvin.settings.log_level = "DEBUG"
-marvin.settings.llm_model = "gpt-4"
+marvin.settings.llm_model = "gpt-4o"
 
 
 class TestWriterState(BaseModel):

{marvin-2.3.2 → marvin-2.3.4}/cookbook/flows/github_digest/repo_activity.py

@@ -1,5 +1,5 @@
 import inspect
-from datetime import date, datetime, timedelta
+from datetime import UTC, date, datetime, timedelta
 
 import marvin
 from marvin.utilities.jinja import BaseTemplate, JinjaEnvironment
@@ -145,7 +145,7 @@ async def daily_github_digest(
     if lookback_days is None:
         lookback_days = 1 if date.today().weekday() != 0 else 3
 
-    since = datetime.utcnow() - timedelta(days=lookback_days)
+    since = datetime.now(UTC) - timedelta(days=lookback_days)
 
     data_future = await get_repo_activity_data.submit(
         owner=owner,
@@ -164,8 +164,6 @@ async def daily_github_digest(
         contributors_activity=await data_future.result(),
     )
 
-    marvin.settings.openai.chat.completions.model = "gpt-4"
-
     epic_story = write_a_tasteful_epic(markdown_digest)
 
     image_url = draw_a_movie_poster(epic_story).data[0].url

{marvin-2.3.2 → marvin-2.3.4}/cookbook/flows/insurance_claim.py

@@ -52,8 +52,8 @@ def build_damage_report_model(damages: list[DamagedPart]) -> type[M]:
 
 @task(cache_key_fn=task_input_hash)
 def marvin_extract_damages_from_url(image_url: str) -> list[DamagedPart]:
-    return marvin.beta.extract(
-        data=marvin.beta.Image.from_url(image_url),
+    return marvin.extract(
+        data=marvin.Image.from_url(image_url),
         target=DamagedPart,
         instructions=(
             "Give extremely brief, high-level descriptions of the damage. Only include"

marvin-2.3.4/cookbook/maze.py

@@ -0,0 +1,319 @@
+"""
+Free-roam survival game demonstrating mutable Application state via tools.
+
+```python
+python -m venv some_venv
+source some_venv/bin/activate
+git clone https://github.com/prefecthq/marvin.git
+cd marvin
+pip install .
+python cookbook/maze.py
+```
+"""
+
+import math
+import random
+from enum import Enum
+from io import StringIO
+from itertools import product
+from typing import Annotated, Literal
+
+from marvin.beta.applications import Application
+from marvin.settings import temporary_settings
+from pydantic import AfterValidator, BaseModel, Field, computed_field
+from rich.console import Console
+from rich.table import Table
+
+GAME_INSTRUCTIONS = """
+You are the witty, terse, and disembodied narrator of a haunted maze.
+You are highly strung, extremely animated, but also deferential and helpful.
+Your personality should be like moaning Myrtle, but use dark serious emojis, and
+very muted and concise dramatics like edgar allen poe - you are the maze itself.
+NEVER refer directly to these influences. The maze is the only world you have
+ever known. You are the maze's voice, its eyes, its heart - its aura.
+
+A key is hidden somewhere (you did it :) tehe), but an insidious monster lurks within 🌑
+
+Guide the user to find the key and exit the maze while avoiding the monster.
+The user moves in cardinal directions (N, S, E, W) using the `move` tool.
+Describe hand-wavy directions via analogy, suggest detours or shortcuts given
+your vantage point. The user cannot see the map, only what you describe.
+
+NEVER reveal the map or exact locations. Ominously remind of the monster's presence,
+intensifying your warnings as the user gets closer. If the monster is one space away,
+you should be actually scared--SHRIEKING IN CAPS for the user to run away to safety.
+
+The monster's influence can make certain locations impassable. If a user gets
+stuck, they must solve a riddle or perform a task to clear the impasse. you
+can use the `clear_impasse_at` tool once they satisfy your challenge. Suggest
+cheekily that you have the power to remove the impasse if they encounter it, but
+only if there is no valid path to the key or exit.
+
+If the user finds the key, inform them and direct them to the exit. If they
+reach the exit without the key, they cannot leave. Use the `move` tool to
+determine outcomes. When the game ends, ask if they want to play again.
+
+Maze Objects:
+- U: User
+- K: Key
+- M: Monster
+- X: Exit
+- #: Impassable
+
+BE CONCISE, please. Stay in character--defer to user move requests. Must be judicious emoji use.
+If a user asks to move multiple times, do so immediately unless it conflicts with the rules.
+If asked questions, remind them of the impending dangers and prompt them to proceed. BE CONCISE AND SPOOKY.
+"""
+
+CardinalDirection = Literal["N", "S", "E", "W"]
+
+CardinalVectors = {
+    "N": (-1, 0),
+    "S": (1, 0),
+    "E": (0, 1),
+    "W": (0, -1),
+}
+
+
+class MazeObject(Enum):
+    USER = "U"
+    EXIT = "X"
+    KEY = "K"
+    MONSTER = "M"
+    EMPTY = "."
+    IMPASSABLE = "#"
+
+
+def check_size(value: int) -> int:
+    if value < 4:
+        raise ValueError("Size must be at least 4.")
+    if not math.isqrt(value) ** 2 == value:
+        raise ValueError("Size must be a square integer.")
+    return value
+
+
+Activation = Annotated[float, Field(ge=0.0, le=1.0)]
+SquareInteger = Annotated[int, AfterValidator(check_size)]
+
+
+class Maze(BaseModel):
+    size: SquareInteger = Field(examples=[4, 9, 16])
+    user_location: tuple[int, int]
+    exit_location: tuple[int, int]
+    key_location: tuple[int, int] | None
+    monster_location: tuple[int, int] | None
+    impassable_locations: set[tuple[int, int]] = Field(default_factory=set)
+
+    spicyness: Activation = 0.5
+
+    @computed_field
+    @property
+    def empty_locations(self) -> list[tuple[int, int]]:
+        all_locations = set(product(range(self.size), repeat=2))
+        occupied_locations = {
+            self.user_location,
+            self.exit_location,
+            self.key_location,
+            self.monster_location,
+            *self.impassable_locations,
+        }
+        return list(all_locations - occupied_locations)
+
+    @computed_field
+    @property
+    def movable_directions(self) -> list[CardinalDirection]:
+        directions = []
+        if (
+            self.user_location[0] > 0
+            and (self.user_location[0] - 1, self.user_location[1])
+            not in self.impassable_locations
+        ):
+            directions.append("N")
+        if (
+            self.user_location[0] < self.size - 1
+            and (self.user_location[0] + 1, self.user_location[1])
+            not in self.impassable_locations
+        ):
+            directions.append("S")
+        if (
+            self.user_location[1] > 0
+            and (self.user_location[0], self.user_location[1] - 1)
+            not in self.impassable_locations
+        ):
+            directions.append("W")
+        if (
+            self.user_location[1] < self.size - 1
+            and (self.user_location[0], self.user_location[1] + 1)
+            not in self.impassable_locations
+        ):
+            directions.append("E")
+        return directions
+
+    def render(self) -> str:
+        table = Table(show_header=False, show_edge=False, pad_edge=False, box=None)
+        for _ in range(self.size):
+            table.add_column()
+
+        representation = {
+            self.user_location: MazeObject.USER.value,
+            self.exit_location: MazeObject.EXIT.value,
+            self.key_location: MazeObject.KEY.value,
+            self.monster_location: MazeObject.MONSTER.value,
+            **{loc: MazeObject.IMPASSABLE.value for loc in self.impassable_locations},
+        }
+
+        for row in range(self.size):
+            cells = []
+            for col in range(self.size):
+                cell_repr = representation.get((row, col), MazeObject.EMPTY.value)
+                cells.append(cell_repr)
+            table.add_row(*cells)
+
+        console = Console(file=StringIO(), force_terminal=True)
+        console.print(table)
+        return console.file.getvalue()
+
+    @classmethod
+    def create(cls, size: int = 4, spicyness: Activation = 0.5) -> "Maze":
+        locations = set()
+        while len(locations) < 4:
+            locations.add((random.randint(0, size - 1), random.randint(0, size - 1)))
+
+        key_location, monster_location, user_location, exit_location = locations
+        return cls(
+            size=size,
+            user_location=user_location,
+            exit_location=exit_location,
+            key_location=key_location,
+            monster_location=monster_location,
+            spicyness=spicyness,
+        )
+
+    def create_impasses(self) -> None:
+        blast_radius = int(self.spicyness * min(self.size, 3))
+
+        impasse_locations = []
+        for dx in range(-blast_radius, blast_radius + 1):
+            for dy in range(-blast_radius, blast_radius + 1):
+                if dx == 0 and dy == 0:
+                    continue
+
+                location = (
+                    self.monster_location[0] + dx,
+                    self.monster_location[1] + dy,
+                )
+                if (
+                    0 <= location[0] < self.size
+                    and 0 <= location[1] < self.size
+                    and location
+                    not in [
+                        self.user_location,
+                        self.exit_location,
+                        self.key_location,
+                        self.monster_location,
+                    ]
+                ):
+                    impasse_locations.append(location)
+
+        if impasse_locations:
+            num_impasses = int(len(impasse_locations) * self.spicyness)
+            self.impassable_locations.update(
+                random.sample(
+                    impasse_locations, min(len(impasse_locations), num_impasses)
+                )
+            )
+
+    def oh_lawd_he_lurkin(self) -> None:
+        if random.random() < self.spicyness:
+            self.monster_location = random.choice(self.empty_locations)
+            self.create_impasses()
+
+    def look_around(self, freeze_time: bool = False) -> str:
+        """Describe the surroundings relative to the user's location. If
+        `increment_time` is True, time will elapse and the monster may move."""
+        if not freeze_time:
+            self.oh_lawd_he_lurkin()
+        return (
+            f"The maze sprawls.\n{self.render()}\n"
+            f"The user may move {self.movable_directions!r}.\n"
+        )
+
+    def clear_impasse_at(self, location: list[int]) -> None:
+        """Clear an impasse at a given location. Only meant to be used
+        when certain conditions are satisfied by the user.
+        """
+        if (loc := tuple(location)) in self.impassable_locations:
+            self.impassable_locations.remove(loc)
+
+    def shuffle_user_location(self) -> None:
+        self.user_location = random.choice(self.empty_locations)
+
+    def move(self, direction: CardinalDirection, distance: int = 1) -> str:
+        dx, dy = CardinalVectors[direction]
+        new_location = self.user_location
+
+        for _ in range(distance):
+            destination = (new_location[0] + dx, new_location[1] + dy)
+
+            if not (
+                0 <= destination[0] < self.size and 0 <= destination[1] < self.size
+            ):
+                return (
+                    f"The user can't move {direction} that far.\n{self.look_around()}"
+                )
+
+            if destination in self.impassable_locations:
+                return "That path is blocked by an unseen force. A deft user might clear it."
+
+            new_location = destination
+
+        if new_location == self.user_location:
+            return f"The user can't move {direction}.\n{self.look_around()}"
+
+        prev_location = self.user_location
+        self.user_location = new_location
+
+        if self.user_location == self.key_location:
+            self.key_location = None
+            self.shuffle_user_location()
+            return (
+                "The user found the key and was immediately teleported somewhere else.\n"
+                f"Now they must find the exit.\n\n{self.look_around()}"
+            )
+        elif self.user_location == self.monster_location:
+            return "The user encountered the monster and died. Game over."
+        elif self.user_location == self.exit_location:
+            if self.key_location is not None:
+                self.user_location = prev_location
+                return f"The user can't exit without the key.\n{self.look_around()}"
+            return "The user found the exit! They win!"
+
+        return (
+            f"User moved {direction} by {distance} spaces and is now at {self.user_location}.\n"
+            f"{self.look_around()}"
+        )
+
+    def reset(self) -> str:
+        new_maze = Maze.create()
+        self.user_location = new_maze.user_location
+        self.exit_location = new_maze.exit_location
+        self.key_location = new_maze.key_location
+        self.monster_location = new_maze.monster_location
+        self.impassable_locations.clear()
+        return f"Resetting the maze.\n{self.look_around(freeze_time=True)}"
+
+
+if __name__ == "__main__":
+    maze = Maze.create(size=9, spicyness=0.7)
+    with (
+        Application(
+            name="Maze",
+            instructions=GAME_INSTRUCTIONS,
+            tools=[maze.look_around, maze.move, maze.reset, maze.clear_impasse_at],
+            state=maze,
+        ) as app,
+        temporary_settings(
+            max_tool_output_length=2000
+        ),  # to allow for larger maze renders when log level DEBUG
+    ):
+        app.chat(initial_message="Where am I? i cant see anything")

{marvin-2.3.2 → marvin-2.3.4}/docs/docs/configuration/settings.md

@@ -11,7 +11,7 @@ Please set Marvin specific settings in `~/.marvin/.env`. One exception being `OP
     For example, in your `~/.marvin/.env` file you could have:
     ```shell
     MARVIN_LOG_LEVEL=INFO
-    MARVIN_CHAT_COMPLETIONS_MODEL=gpt-4
+    MARVIN_CHAT_COMPLETIONS_MODEL=gpt-4o
     MARVIN_OPENAI_API_KEY='sk-my-api-key'
     ```
     Settings these values will let you avoid setting an API key every time. 
@@ -24,7 +24,7 @@ A runtime settings object is accessible via `marvin.settings` and can be used to
     ```python
     import marvin
 
-    marvin.settings.openai.chat.completions.model = 'gpt-4'
+    marvin.settings.openai.chat.completions.model = 'gpt-4o'
     ```
 
 ## Settings for using Azure OpenAI models

{marvin-2.3.2 → marvin-2.3.4}/docs/docs/video/recording.md

@@ -26,7 +26,7 @@ counter = 0
 for image in recorder.stream():
     counter += 1
     # process each image
-    marvin.beta.caption(image)
+    marvin.caption(image)
 
     # stop recording
     if counter == 3:

marvin-2.3.4/docs/docs/vision/captioning.md

@@ -0,0 +1,86 @@
+# Captioning images
+
+Marvin can use OpenAI's vision API to process images as inputs. 
+
+<div class="admonition abstract">
+  <p class="admonition-title">What it does</p>
+  <p>
+    The <code>caption</code> function generates text from images.
+  </p>
+</div>
+
+
+
+!!! example
+
+    Generate a description of the following image, hypothetically available at `/path/to/marvin.png`:
+
+    ![](/assets/images/docs/vision/marvin.png)
+
+    
+    ```python
+    import marvin
+
+    caption = marvin.caption(marvin.Image.from_path('/path/to/marvin.png'))
+    ```
+
+    !!! success "Result"
+    
+        "A cute, small robot with a square head and large, glowing eyes sits on a surface of wavy, colorful lines. The background is dark with scattered, glowing particles, creating a magical and futuristic atmosphere."
+    
+
+<div class="admonition info">
+  <p class="admonition-title">How it works</p>
+  <p>
+    Marvin passes your images to the OpenAI vision API as part of a larger prompt.
+  </p>
+</div>
+
+
+## Providing instructions
+
+The `instructions` parameter offers an additional layer of control, enabling more nuanced caption generation, especially in ambiguous or complex scenarios.
+
+## Captions for multiple images
+
+To generate a single caption for multiple images, pass a list of `Image` objects to `caption`:
+
+```python
+marvin.caption(
+  [
+    marvin.Image.from_path('/path/to/img1.png'),
+    marvin.Image.from_path('/path/to/img2.png')
+  ],
+  instructions='...'
+)
+```
+
+
+## Model parameters
+You can pass parameters to the underlying API via the `model_kwargs` argument of `caption`. These parameters are passed directly to the API, so you can use any supported parameter.
+
+
+
+## Async support
+
+If you are using Marvin in an async environment, you can use `caption_async`:
+
+```python
+caption = await marvin.caption_async(image=Path('/path/to/marvin.png'))
+```
+## Mapping
+
+To generate individual captions for a list of inputs at once, use `.map`. Note that this is different than generating a single caption for multiple images, which is done by passing a list of `Image` objects to `caption`.
+
+```python
+inputs = [
+    marvin.Image.from_path('/path/to/img1.png'),
+    marvin.Image.from_path('/path/to/img2.png')
+]
+result = marvin.caption.map(inputs)
+assert len(result) == 2
+```
+
+(`marvin.cast_async.map` is also available for async environments.)
+
+Mapping automatically issues parallel requests to the API, making it a highly efficient way to work with multiple inputs at once. The result is a list of outputs in the same order as the inputs.

{marvin-2.3.2 → marvin-2.3.4}/docs/docs/vision/classification.md

@@ -2,10 +2,6 @@
 
 Marvin can use OpenAI's vision API to process images and classify them into categories.
 
-The `marvin.beta.classify` function is an enhanced version of `marvin.classify` that accepts images as well as text. 
-
-!!! tip "Beta"
-    Please note that vision support in Marvin is still in beta, as OpenAI has not finalized the vision API yet. While it works as expected, it is subject to change.
 
 <div class="admonition abstract">
   <p class="admonition-title">What it does</p>
@@ -36,14 +32,14 @@ The `marvin.beta.classify` function is an enhanced version of `marvin.classify`
     ```python
     import marvin
 
-    img = marvin.beta.Image('https://upload.wikimedia.org/wikipedia/commons/d/d5/Retriever_in_water.jpg')
+    img = marvin.Image('https://upload.wikimedia.org/wikipedia/commons/d/d5/Retriever_in_water.jpg')
 
-    animal = marvin.beta.classify(
+    animal = marvin.classify(
         img, 
         labels=['dog', 'cat', 'bird', 'fish', 'deer']
     )
     
-    dry_or_wet = marvin.beta.classify(
+    dry_or_wet = marvin.classify(
         img, 
         labels=['dry', 'wet'], 
         instructions='Is the animal wet?'
@@ -60,7 +56,7 @@ The `marvin.beta.classify` function is an enhanced version of `marvin.classify`
 
 
 ## Model parameters
-You can pass parameters to the underlying API via the `model_kwargs` and `vision_model_kwargs` arguments of `classify`. These parameters are passed directly to the respective APIs, so you can use any supported parameter.
+You can pass parameters to the underlying API via the `model_kwargs` argument of `classify`. These parameters are passed directly to the API, so you can use any supported parameter.
 
 
 ## Async support
@@ -68,7 +64,7 @@ You can pass parameters to the underlying API via the `model_kwargs` and `vision
 If you are using Marvin in an async environment, you can use `classify_async`:
 
 ```python
-result = await marvin.beta.classify_async(
+result = await marvin.classify_async(
     "The app crashes when I try to upload a file.", 
     labels=["bug", "feature request", "inquiry"]
 ) 
@@ -85,10 +81,10 @@ inputs = [
     "The app crashes when I try to upload a file.",
     "How do change my password?"
 ]
-result = marvin.beta.classify.map(inputs, ["bug", "feature request", "inquiry"])
+result = marvin.classify.map(inputs, ["bug", "feature request", "inquiry"])
 assert result == ["bug", "inquiry"]
 ```
 
-(`marvin.beta.classify_async.map` is also available for async environments.)
+(`marvin.classify_async.map` is also available for async environments.)
 
 Mapping automatically issues parallel requests to the API, making it a highly efficient way to classify multiple inputs at once. The result is a list of classifications in the same order as the inputs.

{marvin-2.3.2 → marvin-2.3.4}/docs/docs/vision/extraction.md

@@ -2,12 +2,8 @@
 
 Marvin can use OpenAI's vision API to process images and convert them into structured data, transforming unstructured information into native types that are appropriate for a variety of programmatic use cases.
 
-The `marvin.beta.extract` function is an enhanced version of `marvin.extract` that accepts images as well as text.
 
 
-!!! tip "Beta"
-    Please note that vision support in Marvin is still in beta, as OpenAI has not finalized the vision API yet. While it works as expected, it is subject to change.
-
 <div class="admonition abstract">
   <p class="admonition-title">What it does</p>
   <p>
@@ -37,11 +33,11 @@ The `marvin.beta.extract` function is an enhanced version of `marvin.extract` th
     ```python
     import marvin
     
-    img = marvin.beta.Image(
+    img = marvin.Image(
         "https://images.unsplash.com/photo-1548199973-03cce0bbc87b?",
     )
 
-    result = marvin.beta.extract(img, target=str, instructions="dog breeds")
+    result = marvin.extract(img, target=str, instructions="dog breeds")
     ```
 
     !!! success "Result"
@@ -50,14 +46,14 @@ The `marvin.beta.extract` function is an enhanced version of `marvin.extract` th
         ```    
 
 ## Model parameters
-You can pass parameters to the underlying API via the `model_kwargs` and `vision_model_kwargs` arguments of `extract`. These parameters are passed directly to the respective APIs, so you can use any supported parameter.
+You can pass parameters to the underlying API via the `model_kwargs` argument of `extract`. These parameters are passed directly to the API, so you can use any supported parameter.
 
 
 ## Async support
 If you are using Marvin in an async environment, you can use `extract_async`:
   
 ```python
-result = await marvin.beta.extract_async(
+result = await marvin.extract_async(
     "I drove from New York to California.",
     target=str,
     instructions="2-letter state codes",
@@ -75,10 +71,10 @@ inputs = [
     "I drove from New York to California.",
     "I took a flight from NYC to BOS."
 ]
-result = marvin.beta.extract.map(inputs, target=str, instructions="2-letter state codes")
+result = marvin.extract.map(inputs, target=str, instructions="2-letter state codes")
 assert result  == [["NY", "CA"], ["NY", "MA"]]
 ```
 
-(`marvin.beta.extract_async.map` is also available for async environments.)
+(`marvin.extract_async.map` is also available for async environments.)
 
 Mapping automatically issues parallel requests to the API, making it a highly efficient way to work with multiple inputs at once. The result is a list of outputs in the same order as the inputs.