together 1.5.34__py3-none-any.whl → 2.0.0a6__py3-none-any.whl

together/{utils → lib/utils}/files.py

@@ -1,37 +1,26 @@
 from __future__ import annotations
 
+import os
 import csv
 import json
-import os
+from typing import Any, Dict, List, cast
 from pathlib import Path
 from traceback import format_exc
-from typing import Any, Dict, List
 
 from tqdm import tqdm
 
-from together.constants import (
-    JSONL_REQUIRED_COLUMNS_MAP,
-    MAX_BASE64_IMAGE_LENGTH,
-    MAX_FILE_SIZE_GB,
-    MAX_IMAGES_PER_EXAMPLE,
+from together.types import FilePurpose
+from together.lib.constants import (
     MIN_SAMPLES,
+    DISABLE_TQDM,
     NUM_BYTES_IN_GB,
+    MAX_FILE_SIZE_GB,
     PARQUET_EXPECTED_COLUMNS,
-    POSSIBLE_ROLES_CONVERSATION,
     REQUIRED_COLUMNS_MESSAGE,
+    JSONL_REQUIRED_COLUMNS_MAP,
+    POSSIBLE_ROLES_CONVERSATION,
     DatasetFormat,
 )
-from together.types import FilePurpose
-
-
-# MessageContent is a string or a list of dicts with 'type': 'text' or 'image_url', and 'text' or 'image_url.url'
-# Example: "Hello" or [
-#   {"type": "text", "text": "Hello"},
-#   {"type": "image_url", "image_url": {
-#     "url": "data:image/jpeg;base64,..."
-#   }}
-# ]
-MessageContent = str | list[dict[str, Any]]
 
 
 class InvalidFileFormatError(ValueError):
@@ -51,12 +40,12 @@ class InvalidFileFormatError(ValueError):
 
 def check_file(
     file: Path | str,
-    purpose: FilePurpose | str = FilePurpose.FineTune,
+    purpose: FilePurpose | str = "fine-tune",
 ) -> Dict[str, Any]:
     if not isinstance(file, Path):
         file = Path(file)
 
-    report_dict = {
+    report_dict: Dict[str, Any] = {
         "is_check_passed": True,
         "message": "Checks passed",
         "found": None,
@@ -78,7 +67,7 @@ def check_file(
     else:
         report_dict["found"] = True
 
-    file_size = os.stat(file).st_size
+    file_size = os.stat(file.as_posix()).st_size
 
     if file_size > MAX_FILE_SIZE_GB * NUM_BYTES_IN_GB:
         report_dict["message"] = (
@@ -105,8 +94,7 @@ def check_file(
         data_report_dict = _check_csv(file, purpose)
     else:
         report_dict["filetype"] = (
-            f"Unknown extension of file {file}. "
-            "Only files with extensions .jsonl and .parquet are supported."
+            f"Unknown extension of file {file}. Only files with extensions .jsonl, .parquet, and .csv are supported."
         )
         report_dict["is_check_passed"] = False
 
@@ -115,9 +103,7 @@ def check_file(
     return report_dict
 
 
-def _check_conversation_type(
-    messages: List[Dict[str, str | int | MessageContent]], idx: int
-) -> None:
+def _check_conversation_type(messages: List[Dict[str, str | bool]], idx: int) -> None:
     """Check that the conversation has correct type.
 
     Args:
@@ -128,23 +114,22 @@ def _check_conversation_type(
     Raises:
         InvalidFileFormatError: If the conversation type is invalid.
     """
-    if not isinstance(messages, list):
-        raise InvalidFileFormatError(
-            message=f"Invalid format on line {idx + 1} of the input file. "
-            f"The `messages` column must be a list. Found {type(messages)}",
-            line_number=idx + 1,
-            error_source="key_value",
-        )
+    # if not isinstance(messages, list):
+    #     raise InvalidFileFormatError(
+    #         message=f"Invalid format on line {idx + 1} of the input file. "
+    #         f"The `messages` column must be a list. Found {type(messages)}",
+    #         line_number=idx + 1,
+    #         error_source="key_value",
+    #     )
     if len(messages) == 0:
         raise InvalidFileFormatError(
-            message=f"Invalid format on line {idx + 1} of the input file. "
-            f"The `messages` column must not be empty.",
+            message=f"Invalid format on line {idx + 1} of the input file. The `messages` column must not be empty.",
             line_number=idx + 1,
             error_source="key_value",
         )
 
     for message in messages:
-        if not isinstance(message, dict):
+        if not isinstance(cast(Any, message), dict):
             raise InvalidFileFormatError(
                 message=f"Invalid format on line {idx + 1} of the input file. "
                 f"The `messages` column must be a list of dicts. Found {type(message)}",
@@ -159,11 +144,15 @@ def _check_conversation_type(
                     line_number=idx + 1,
                     error_source="key_value",
                 )
+            if not isinstance(message[column], str):
+                raise InvalidFileFormatError(
+                    message=f"Column `{column}` is not a string on line {idx + 1}. Found {type(message[column])}",
+                    line_number=idx + 1,
+                    error_source="text_field",
+                )
 
 
-def _check_conversation_roles(
-    require_assistant_role: bool, assistant_role_exists: bool, idx: int
-) -> None:
+def _check_conversation_roles(require_assistant_role: bool, assistant_role_exists: bool, idx: int) -> None:
     """Check that the conversation has correct roles.
 
     Args:
@@ -183,9 +172,7 @@ def _check_conversation_roles(
         )
 
 
-def _check_message_weight(
-    message: Dict[str, str | int | MessageContent], idx: int
-) -> int | None:
+def _check_message_weight(message: Dict[str, str | bool], idx: int) -> None:
     """Check that the message has a weight with the correct type and value.
 
     Args:
@@ -209,14 +196,9 @@ def _check_message_weight(
                 line_number=idx + 1,
                 error_source="key_value",
             )
-        return weight
 
-    return None
 
-
-def _check_message_role(
-    message: Dict[str, str | int | MessageContent], previous_role: str | None, idx: int
-) -> str:
+def _check_message_role(message: Dict[str, str | bool], previous_role: str | bool | None, idx: int) -> str | bool:
     """Check that the message has correct roles.
 
     Args:
@@ -230,14 +212,6 @@ def _check_message_role(
     Raises:
         InvalidFileFormatError: If the message role is invalid.
     """
-    if not isinstance(message["role"], str):
-        raise InvalidFileFormatError(
-            message=f"Invalid role `{message['role']}` in conversation on line {idx + 1}. "
-            f"Role must be a string. Found {type(message['role'])}",
-            line_number=idx + 1,
-            error_source="key_value",
-        )
-
     if message["role"] not in POSSIBLE_ROLES_CONVERSATION:
         raise InvalidFileFormatError(
             message=f"Invalid role `{message['role']}` in conversation on line {idx + 1}. "
@@ -255,135 +229,7 @@ def _check_message_role(
     return message["role"]
 
 
-def _check_message_content(
-    message_content: str | int | MessageContent, role: str, idx: int
-) -> tuple[bool, int]:
-    """Check that the message content has the correct type.
-    Message content can be either a) a string or b) an OpenAI-style multimodal list of content items
-    Example:
-        a) "Hello", or
-        b) [
-             {"type": "text", "text": "Hello"},
-             {"type": "image_url", "image_url": {
-                "url": "data:image/jpeg;base64,..."
-             }}
-           ]
-
-    Args:
-        message: The message to check.
-        role: The role of the message.
-        idx: Line number in the file.
-
-    Returns:
-        tuple[bool, int]: A tuple with message is multimodal and the number of images in the message content.
-    """
-    # Text-only message content
-    if isinstance(message_content, str):
-        return False, 0
-
-    # Multimodal message content
-    if isinstance(message_content, list):
-        num_images = 0
-        for item in message_content:
-            if not isinstance(item, dict):
-                raise InvalidFileFormatError(
-                    "The dataset is malformed, the `content` field must be a list of dicts.",
-                    line_number=idx + 1,
-                    error_source="key_value",
-                )
-            if "type" not in item:
-                raise InvalidFileFormatError(
-                    "The dataset is malformed, the `content` field must be a list of dicts with a `type` field.",
-                    line_number=idx + 1,
-                    error_source="key_value",
-                )
-
-            if item["type"] == "text":
-                if "text" not in item or not isinstance(item["text"], str):
-                    raise InvalidFileFormatError(
-                        "The dataset is malformed, the `text` field must be present in the `content` item field and be"
-                        f" a string. Got '{item.get('text')!r}' instead.",
-                        line_number=idx + 1,
-                        error_source="key_value",
-                    )
-            elif item["type"] == "image_url":
-                if role != "user":
-                    raise InvalidFileFormatError(
-                        "The dataset is malformed, only user messages can contain images.",
-                        line_number=idx + 1,
-                        error_source="key_value",
-                    )
-
-                if "image_url" not in item or not isinstance(item["image_url"], dict):
-                    raise InvalidFileFormatError(
-                        "The dataset is malformed, the `image_url` field must be present in the `content` field and "
-                        f"be a dictionary. Got {item.get('image_url')!r} instead.",
-                        line_number=idx + 1,
-                        error_source="key_value",
-                    )
-
-                image_data = item["image_url"].get("url")
-                if not image_data or not isinstance(image_data, str):
-                    raise InvalidFileFormatError(
-                        "The dataset is malformed, the `url` field must be present in the `image_url` field and be "
-                        f"a string. Got {image_data!r} instead.",
-                        line_number=idx + 1,
-                        error_source="key_value",
-                    )
-
-                if not any(
-                    image_data.startswith(f"data:image/{fmt};base64,")
-                    for fmt in ["jpeg", "png", "webp"]
-                ):
-                    raise InvalidFileFormatError(
-                        "The dataset is malformed, the `url` field must be either a JPEG, PNG or WEBP base64-encoded "
-                        "image in 'data:image/<format>;base64,<base64_encoded_image>' format. "
-                        f"Got '{image_data[:100]}...' instead.",
-                        line_number=idx + 1,
-                    )
-
-                if len(image_data) > MAX_BASE64_IMAGE_LENGTH:
-                    raise InvalidFileFormatError(
-                        "The dataset is malformed, the `url` field must contain base64-encoded image "
-                        f"that is less than 10MB, found ~{len(image_data) * 3 // 4} bytes.",
-                        line_number=idx + 1,
-                        error_source="key_value",
-                    )
-
-                num_images += 1
-            else:
-                raise InvalidFileFormatError(
-                    "The dataset is malformed, the `type` field must be either 'text' or 'image_url'. "
-                    f"Got {item['type']!r}.",
-                    line_number=idx + 1,
-                    error_source="key_value",
-                )
-
-        if num_images > MAX_IMAGES_PER_EXAMPLE:
-            raise InvalidFileFormatError(
-                f"The dataset is malformed, the `content` field must contain at most "
-                f"{MAX_IMAGES_PER_EXAMPLE} images, found {num_images}.",
-                line_number=idx + 1,
-                error_source="key_value",
-            )
-
-        # We still consider text-only messages in such format as multimodal, even if they don't have any images
-        # included - so we can process datasets with rather sparse images (i.e. not in each sample) consistently.
-        return True, num_images
-
-    raise InvalidFileFormatError(
-        f"Invalid content type on line {idx + 1} of the input file. Expected string or multimodal list of dicts, "
-        f"found {type(message_content)}",
-        line_number=idx + 1,
-        error_source="key_value",
-    )
-
-
-def validate_messages(
-    messages: List[Dict[str, str | int | MessageContent]],
-    idx: int,
-    require_assistant_role: bool = True,
-) -> None:
+def validate_messages(messages: List[Dict[str, str | bool]], idx: int, require_assistant_role: bool = True) -> None:
     """Validate the messages column.
 
     Args:
@@ -396,45 +242,15 @@ def validate_messages(
     """
     _check_conversation_type(messages, idx)
 
+    has_weights = any("weight" in message for message in messages)
     previous_role = None
     assistant_role_exists = False
 
-    messages_are_multimodal: bool | None = None
-    total_number_of_images = 0
-
     for message in messages:
-        message_weight = _check_message_weight(message, idx)
+        if has_weights:
+            _check_message_weight(message, idx)
         previous_role = _check_message_role(message, previous_role, idx)
         assistant_role_exists |= previous_role == "assistant"
-        is_multimodal, number_of_images = _check_message_content(
-            message["content"], role=previous_role, idx=idx
-        )
-        # Multimodal validation
-        if number_of_images > 0 and message_weight is not None and message_weight != 0:
-            raise InvalidFileFormatError(
-                "Messages with images cannot have non-zero weights.",
-                line_number=idx + 1,
-                error_source="key_value",
-            )
-        if messages_are_multimodal is None:
-            # Detect the format of the messages in the conversation.
-            messages_are_multimodal = is_multimodal
-        elif messages_are_multimodal != is_multimodal:
-            # Due to the format limitation, we cannot mix multimodal and text only messages in the same sample.
-            raise InvalidFileFormatError(
-                "Messages in the conversation must be either all in multimodal or all in text-only format.",
-                line_number=idx + 1,
-                error_source="key_value",
-            )
-        total_number_of_images += number_of_images
-
-    if total_number_of_images > MAX_IMAGES_PER_EXAMPLE:
-        raise InvalidFileFormatError(
-            f"The dataset is malformed, the `messages` must contain at most {MAX_IMAGES_PER_EXAMPLE} images. "
-            f"Found {total_number_of_images} images.",
-            line_number=idx + 1,
-            error_source="key_value",
-        )
 
     _check_conversation_roles(require_assistant_role, assistant_role_exists, idx)
 
@@ -463,7 +279,8 @@ def validate_preference_openai(example: Dict[str, Any], idx: int = 0) -> None:
             error_source="key_value",
         )
 
-    validate_messages(example["input"]["messages"], idx, require_assistant_role=False)
+    messages: List[Dict[str, str | bool]] = cast(Any, example["input"]["messages"])
+    validate_messages(messages, idx, require_assistant_role=False)
 
     if example["input"]["messages"][-1]["role"] == "assistant":
         raise InvalidFileFormatError(
@@ -524,7 +341,12 @@ def validate_preference_openai(example: Dict[str, Any], idx: int = 0) -> None:
                 error_source="key_value",
             )
 
-        _check_message_content(example[key][0]["content"], role="assistant", idx=idx)
+        if not isinstance(example[key][0]["content"], str):
+            raise InvalidFileFormatError(
+                message=f"The dataset is malformed, the 'content' field in `{key}` must be a string on line {idx + 1}.",
+                line_number=idx + 1,
+                error_source="key_value",
+            )
 
 
 def _check_utf8(file: Path) -> Dict[str, Any]:
@@ -536,30 +358,24 @@ def _check_utf8(file: Path) -> Dict[str, Any]:
         Dict[str, Any]: A dictionary with the results of the check.
     """
     report_dict: Dict[str, Any] = {}
-
     try:
-        # Dry-run UTF-8 decode: iterate through file to validate encoding
+        # Dry-run UTF-8 decode by iterating through the file to avoid loading it entirely into memory
         with file.open(encoding="utf-8") as f:
             for _ in f:
                 pass
-
         report_dict["utf8"] = True
     except UnicodeDecodeError as e:
         report_dict["utf8"] = False
         report_dict["message"] = f"File is not UTF-8 encoded. Error raised: {e}."
         report_dict["is_check_passed"] = False
-
     return report_dict
 
 
-def _check_samples_count(
-    file: Path, report_dict: Dict[str, Any], idx: int
-) -> Dict[str, Any]:
+def _check_samples_count(file: Path, report_dict: Dict[str, Any], idx: int) -> Dict[str, Any]:
     if idx + 1 < MIN_SAMPLES:
         report_dict["has_min_samples"] = False
         report_dict["message"] = (
-            f"Processing {file} resulted in only {idx + 1} samples. "
-            f"Our minimum is {MIN_SAMPLES} samples. "
+            f"Processing {file} resulted in only {idx + 1} samples. Our minimum is {MIN_SAMPLES} samples. "
         )
         report_dict["is_check_passed"] = False
     else:
@@ -580,11 +396,10 @@ def _check_csv(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
         Dict[str, Any]: A dictionary with the results of the check.
     """
     report_dict: Dict[str, Any] = {}
-    if purpose != FilePurpose.Eval:
+    if purpose != "eval":
         report_dict["is_check_passed"] = False
         report_dict["message"] = (
-            f"CSV files are not supported for {purpose}. "
-            "Only JSONL and Parquet files are supported."
+            f"CSV files are not supported for {purpose}. Only JSONL and Parquet files are supported."
         )
         return report_dict
 
@@ -625,13 +440,9 @@ def _check_csv(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
         except ValueError:
             report_dict["load_csv"] = False
             if idx < 0:
-                report_dict["message"] = (
-                    "Unable to decode file. File may be empty or in an unsupported format. "
-                )
+                report_dict["message"] = "Unable to decode file. File may be empty or in an unsupported format. "
             else:
-                report_dict["message"] = (
-                    f"Error parsing the CSV file. Unexpected format on line {idx + 1}."
-                )
+                report_dict["message"] = f"Error parsing the CSV file. Unexpected format on line {idx + 1}."
             report_dict["is_check_passed"] = False
 
     return report_dict
@@ -647,7 +458,12 @@ def _check_jsonl(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
     with file.open() as f:
         idx = -1
         try:
-            for idx, line in tqdm(enumerate(f), desc="Validating file", unit=" lines"):
+            for idx, line in tqdm(
+                enumerate(f),
+                desc="Validating file",
+                unit=" lines",
+                disable=bool(DISABLE_TQDM),
+            ):
                 json_line = json.loads(line)
 
                 if not isinstance(json_line, dict):
@@ -661,16 +477,13 @@ def _check_jsonl(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
                         error_source="line_type",
                     )
                 # In evals, we don't check the format of the dataset.
-                if purpose != FilePurpose.Eval:
+                if purpose != "eval":
                     current_format = None
                     for possible_format in JSONL_REQUIRED_COLUMNS_MAP:
-                        if all(
-                            column in json_line
-                            for column in JSONL_REQUIRED_COLUMNS_MAP[possible_format]
-                        ):
+                        if all(column in json_line for column in JSONL_REQUIRED_COLUMNS_MAP[possible_format]):
                             if current_format is None:
                                 current_format = possible_format
-                            elif current_format != possible_format:
+                            elif current_format != possible_format:  # type: ignore[unreachable]
                                 raise InvalidFileFormatError(
                                     message="Found multiple dataset formats in the input file. "
                                     f"Got {current_format} and {possible_format} on line {idx + 1}.",
@@ -679,11 +492,8 @@ def _check_jsonl(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
                                 )
 
                             # Check that there are no extra columns
-                            for column in json_line:
-                                if (
-                                    column
-                                    not in JSONL_REQUIRED_COLUMNS_MAP[possible_format]
-                                ):
+                            for column in cast(List[str], json_line.keys()):
+                                if column not in JSONL_REQUIRED_COLUMNS_MAP[possible_format]:
                                     raise InvalidFileFormatError(
                                         message=f'Found extra column "{column}" in the line {idx + 1}.',
                                         line_number=idx + 1,
@@ -700,36 +510,36 @@ def _check_jsonl(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
                             error_source="format",
                         )
                     if current_format == DatasetFormat.PREFERENCE_OPENAI:
-                        validate_preference_openai(json_line, idx)
+                        validate_preference_openai(cast(Dict[str, Any], json_line), idx)
                     elif current_format == DatasetFormat.CONVERSATION:
-                        message_column = JSONL_REQUIRED_COLUMNS_MAP[
-                            DatasetFormat.CONVERSATION
-                        ][0]
-                        require_assistant = purpose != FilePurpose.Eval
+                        message_column = JSONL_REQUIRED_COLUMNS_MAP[DatasetFormat.CONVERSATION][0]
+                        require_assistant = purpose != "eval"
+                        message: List[Dict[str, str | bool]] = cast(Any, json_line[message_column])
                         validate_messages(
-                            json_line[message_column],
+                            message,
                             idx,
                             require_assistant_role=require_assistant,
                         )
                     else:
                         for column in JSONL_REQUIRED_COLUMNS_MAP[current_format]:
-                            role = "assistant" if column in {"completion"} else "user"
-                            _check_message_content(
-                                json_line[column], role=role, idx=idx
-                            )
+                            if not isinstance(json_line[column], str):
+                                raise InvalidFileFormatError(
+                                    message=f'Invalid value type for "{column}" key on line {idx + 1}. '
+                                    f"Expected string. Found {type(cast(Any, json_line[column]))}.",
+                                    line_number=idx + 1,
+                                    error_source="key_value",
+                                )
 
                     if dataset_format is None:
                         dataset_format = current_format
-                    elif current_format is not None:
-                        if current_format != dataset_format:
-                            raise InvalidFileFormatError(
-                                message="All samples in the dataset must have the same dataset format. "
-                                f"Got {dataset_format} for the first line and {current_format} "
-                                f"for the line {idx + 1}.",
-                                line_number=idx + 1,
-                                error_source="format",
-                            )
-
+                    elif current_format != dataset_format:  # type: ignore[unreachable]
+                        raise InvalidFileFormatError(
+                            message="All samples in the dataset must have the same dataset format. "
+                            f"Got {dataset_format} for the first line and {current_format} "
+                            f"for the line {idx + 1}.",
+                            line_number=idx + 1,
+                            error_source="format",
+                        )
             report_dict.update(_check_samples_count(file, report_dict, idx))
 
             report_dict["load_json"] = True
@@ -745,13 +555,9 @@ def _check_jsonl(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
         except ValueError:
             report_dict["load_json"] = False
             if idx < 0:
-                report_dict["message"] = (
-                    "Unable to decode file. File may be empty or in an unsupported format. "
-                )
+                report_dict["message"] = "Unable to decode file. File may be empty or in an unsupported format. "
             else:
-                report_dict["message"] = (
-                    f"Error parsing json payload. Unexpected format on line {idx + 1}."
-                )
+                report_dict["message"] = f"Error parsing json payload. Unexpected format on line {idx + 1}."
             report_dict["is_check_passed"] = False
 
     if "text_field" not in report_dict:
@@ -767,22 +573,21 @@ def _check_parquet(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
     try:
         # Pyarrow is optional as it's large (~80MB) and isn't compatible with older systems.
         from pyarrow import ArrowInvalid, parquet
-    except ImportError:
+    except ImportError as e:
         raise ImportError(
             "pyarrow is not installed and is required to use parquet files. Please install it via `pip install together[pyarrow]`"
-        )
+        ) from e
 
     report_dict: Dict[str, Any] = {}
-    if purpose == FilePurpose.Eval:
+    if purpose == "eval":
         report_dict["is_check_passed"] = False
         report_dict["message"] = (
-            f"Parquet files are not supported for {purpose}. "
-            "Only JSONL and CSV files are supported."
+            f"Parquet files are not supported for {purpose}. Only JSONL and CSV files are supported."
         )
         return report_dict
 
     try:
-        table = parquet.read_table(str(file), memory_map=True)
+        table = parquet.read_table(str(file), memory_map=True)  # type: ignore[reportUnknownMemberType]
     except ArrowInvalid:
         report_dict["load_parquet"] = (
             f"An exception has occurred when loading the Parquet file {file}. Please check the file for corruption. "
@@ -793,9 +598,7 @@ def _check_parquet(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
 
     column_names = table.schema.names
     if "input_ids" not in column_names:
-        report_dict["load_parquet"] = (
-            f"Parquet file {file} does not contain the `input_ids` column."
-        )
+        report_dict["load_parquet"] = f"Parquet file {file} does not contain the `input_ids` column."
         report_dict["is_check_passed"] = False
         return report_dict
 
@@ -813,8 +616,7 @@ def _check_parquet(file: Path, purpose: FilePurpose | str) -> Dict[str, Any]:
     if num_samples < MIN_SAMPLES:
         report_dict["has_min_samples"] = False
         report_dict["message"] = (
-            f"Processing {file} resulted in only {num_samples} samples. "
-            f"Our minimum is {MIN_SAMPLES} samples. "
+            f"Processing {file} resulted in only {num_samples} samples. Our minimum is {MIN_SAMPLES} samples. "
         )
         report_dict["is_check_passed"] = False
         return report_dict

together/lib/utils/serializer.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from typing import Any
+from datetime import datetime
+
+
+def datetime_serializer(obj: Any) -> str:
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")