evalscope 0.17.1__py3-none-any.whl → 1.0.1__py3-none-any.whl

evalscope/utils/json_schema.py

@@ -0,0 +1,208 @@
+import types
+import typing
+from copy import deepcopy
+from dataclasses import is_dataclass
+from datetime import date, datetime, time
+from enum import EnumMeta
+from pydantic import BaseModel, Field
+from typing import (
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+    is_typeddict,
+)
+
+JSONType = Literal['string', 'integer', 'number', 'boolean', 'array', 'object', 'null']
+"""Valid types within JSON schema."""
+
+
+class JSONSchema(BaseModel):
+    """JSON Schema for type."""
+
+    type: Optional[JSONType] = Field(default=None)
+    """JSON type of tool parameter."""
+
+    format: Optional[str] = Field(default=None)
+    """Format of the parameter (e.g. date-time)."""
+
+    description: Optional[str] = Field(default=None)
+    """Parameter description."""
+
+    default: Any = Field(default=None)
+    """Default value for parameter."""
+
+    enum: Optional[List[Any]] = Field(default=None)
+    """Valid values for enum parameters."""
+
+    items: Optional['JSONSchema'] = Field(default=None)
+    """Valid type for array parameters."""
+
+    properties: Optional[Dict[str, 'JSONSchema']] = Field(default=None)
+    """Valid fields for object parametrs."""
+
+    additionalProperties: Optional[Union['JSONSchema', bool]] = Field(default=None)
+    """Are additional properties allowed?"""
+
+    anyOf: Optional[List['JSONSchema']] = Field(default=None)
+    """Valid types for union parameters."""
+
+    required: Optional[List[str]] = Field(default=None)
+    """Required fields for object parameters."""
+
+
+def json_schema(t: Type[Any]) -> JSONSchema:
+    """Provide a JSON Schema for the specified type.
+
+    Schemas can be automatically inferred for a wide variety of
+    Python class types including Pydantic BaseModel, dataclasses,
+    and typed dicts.
+
+    Args:
+        t: Python type
+
+    Returns:
+        JSON Schema for type.
+    """
+    origin = get_origin(t)
+    args = get_args(t)
+
+    if origin is None:
+        if t is int:
+            return JSONSchema(type='integer')
+        elif t is float:
+            return JSONSchema(type='number')
+        elif t is str:
+            return JSONSchema(type='string')
+        elif t is bool:
+            return JSONSchema(type='boolean')
+        elif t is datetime:
+            return JSONSchema(type='string', format='date-time')
+        elif t is date:
+            return JSONSchema(type='string', format='date')
+        elif t is time:
+            return JSONSchema(type='string', format='time')
+        elif t is list or t is set:
+            return JSONSchema(type='array', items=JSONSchema())
+        elif t is dict:
+            return JSONSchema(type='object', additionalProperties=JSONSchema())
+        elif (is_dataclass(t) or is_typeddict(t) or (isinstance(t, type) and issubclass(t, BaseModel))):
+            return cls_json_schema(t)
+        elif isinstance(t, EnumMeta):
+            return JSONSchema(enum=[item.value for item in t])
+        elif t is type(None):
+            return JSONSchema(type='null')
+        else:
+            return JSONSchema()
+    elif (origin is list or origin is List or origin is tuple or origin is Tuple or origin is set or origin is Set):
+        return JSONSchema(type='array', items=json_schema(args[0]) if args else JSONSchema())
+    elif origin is dict or origin is Dict:
+        return JSONSchema(
+            type='object',
+            additionalProperties=json_schema(args[1]) if len(args) > 1 else JSONSchema(),
+        )
+    elif origin is Union or origin is types.UnionType:
+        return JSONSchema(anyOf=[json_schema(arg) for arg in args])
+    elif origin is Optional:
+        return JSONSchema(anyOf=[json_schema(arg) for arg in args] + [JSONSchema(type='null')])
+    elif origin is typing.Literal:
+        return JSONSchema(enum=list(args))
+
+    return JSONSchema()  # Default case if we can't determine the type
+
+
+def cls_json_schema(cls: Type[Any]) -> JSONSchema:
+    properties: Dict[str, JSONSchema] = {}
+    required: List[str] = []
+
+    if is_dataclass(cls):
+        fields = cls.__dataclass_fields__  # type: ignore
+        for name, field in fields.items():
+            properties[name] = json_schema(field.type)  # type: ignore
+            if field.default == field.default_factory:
+                required.append(name)
+    elif isinstance(cls, type) and issubclass(cls, BaseModel):
+        schema = cls.model_json_schema()
+        schema = resolve_schema_references(schema)
+        for name, prop in schema.get('properties', {}).items():
+            properties[name] = JSONSchema(**prop)
+        required = schema.get('required', [])
+    elif is_typeddict(cls):
+        annotations = get_type_hints(cls)
+        for name, type_hint in annotations.items():
+            properties[name] = json_schema(type_hint)
+            if name in cls.__required_keys__:
+                required.append(name)
+
+    return JSONSchema(
+        type='object',
+        properties=properties,
+        required=required if required else None,
+        additionalProperties=False,
+    )
+
+
+def python_type_to_json_type(python_type: Optional[str]) -> JSONType:
+    if python_type == 'str':
+        return 'string'
+    elif python_type == 'int':
+        return 'integer'
+    elif python_type == 'float':
+        return 'number'
+    elif python_type == 'bool':
+        return 'boolean'
+    elif python_type == 'list':
+        return 'array'
+    elif python_type == 'dict':
+        return 'object'
+    elif python_type == 'None':
+        return 'null'
+    elif python_type is None:
+        # treat 'unknown' as string as anything can be converted to string
+        return 'string'
+    else:
+        raise ValueError(f'Unsupported type: {python_type} for Python to JSON conversion.')
+
+
+def resolve_schema_references(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Resolves all $ref references in a JSON schema by inlining the definitions."""
+    schema = deepcopy(schema)
+    definitions = schema.pop('$defs', {})
+
+    def _resolve_refs(obj: Any) -> Any:
+        if isinstance(obj, dict):
+            if '$ref' in obj and obj['$ref'].startswith('#/$defs/'):
+                ref_key = obj['$ref'].split('/')[-1]
+                if ref_key in definitions:
+                    # Replace with a deep copy of the definition
+                    resolved = deepcopy(definitions[ref_key])
+                    # Process any nested references in the definition
+                    resolved = _resolve_refs(resolved)
+
+                    # Merge in the current object fields, which should take priority
+                    # This means that if you have e.g.
+                    # {"$ref": "#/$defs/SubType", "description": "subtype of type SubType"},
+                    # and SubType resolves to
+                    # {"description": "The SubType Class", "parameters": {"param1": {"type": "string"}}},
+                    # the final result will be:
+                    # {"description": "subtype of type SubType", "parameters": {"param1": {"type": "string"}}}
+                    return resolved | {k: o for k, o in obj.items() if k != '$ref'}
+
+            # Process all entries in the dictionary
+            return {k: _resolve_refs(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [_resolve_refs(item) for item in obj]
+        else:
+            return obj
+
+    return cast(Dict[str, Any], _resolve_refs(schema))
+    return cast(Dict[str, Any], _resolve_refs(schema))

evalscope/utils/logger.py

@@ -1,18 +1,27 @@
+import colorlog
 import importlib.util as iutil
 import logging
 import os
-from typing import Optional
+from logging import Logger
+from typing import List, Optional
 
 init_loggers = {}
+# Define log formats
+data_format = '%Y-%m-%d %H:%M:%S'
+# For console output
+color_detailed_format = '%(asctime)s - %(name)s - %(filename)s - %(funcName)s - %(lineno)d - %(log_color)s%(levelname)s%(reset)s: %(message)s'  # noqa:E501
+color_simple_format = '%(asctime)s - %(name)s - %(log_color)s%(levelname)s%(reset)s: %(message)s'
+color_detailed_formatter = colorlog.ColoredFormatter(color_detailed_format, datefmt=data_format)
+color_simple_formatter = colorlog.ColoredFormatter(color_simple_format, datefmt=data_format)
+# For file output
+detailed_format = '%(asctime)s - %(name)s - %(filename)s - %(funcName)s - %(lineno)d - %(levelname)s: %(message)s'  # noqa:E501
+simple_format = '%(asctime)s - %(name)s - %(levelname)s: %(message)s'
+plain_detailed_formatter = logging.Formatter(detailed_format, datefmt=data_format)
+plain_simple_formatter = logging.Formatter(simple_format, datefmt=data_format)
 
-detailed_format = '%(asctime)s - %(name)s - %(filename)s - %(funcName)s - %(lineno)d - %(levelname)s - %(message)s'
-simple_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-
-detailed_formatter = logging.Formatter(detailed_format)
-simple_formatter = logging.Formatter(simple_format)
 DEFAULT_LEVEL = logging.DEBUG if os.getenv('EVALSCOPE_LOG_LEVEL', 'INFO') == 'DEBUG' else logging.INFO
 
-logging.basicConfig(format=simple_format, level=DEFAULT_LEVEL, force=True)
+logging.basicConfig(format=simple_format, level=logging.INFO, force=True)
 
 # set logging level
 logging.getLogger('datasets').setLevel(logging.WARNING)
@@ -20,7 +29,13 @@ logging.getLogger('httpx').setLevel(logging.WARNING)
 logging.getLogger('modelscope').setLevel(logging.ERROR)
 
 
-def get_logger(log_file: Optional[str] = None, log_level: int = DEFAULT_LEVEL, file_mode: str = 'w', force=False):
+def get_logger(
+    log_file: Optional[str] = None,
+    name: Optional[str] = None,
+    log_level: int = DEFAULT_LEVEL,
+    file_mode: str = 'w',
+    force=False
+):
     """Get logging logger
 
     Args:
@@ -31,7 +46,10 @@ def get_logger(log_file: Optional[str] = None, log_level: int = DEFAULT_LEVEL, f
             specified (if filemode is unspecified, it defaults to 'w').
     """
 
-    logger_name = __name__.split('.')[0]
+    if name:
+        logger_name = f"evalscope.{name.split('.')[-1]}"
+    else:
+        logger_name = 'evalscope'
     logger = logging.getLogger(logger_name)
     logger.propagate = False
 
@@ -40,7 +58,15 @@ def get_logger(log_file: Optional[str] = None, log_level: int = DEFAULT_LEVEL, f
             logger.setLevel(log_level)
             for handler in logger.handlers:
                 handler.setLevel(log_level)
-                handler.setFormatter(detailed_formatter if log_level == logging.DEBUG else simple_formatter)
+                # 区分不同类型的 handler，使用相应的格式化器
+                if isinstance(handler, logging.FileHandler):
+                    handler.setFormatter(
+                        plain_detailed_formatter if log_level == logging.DEBUG else plain_simple_formatter
+                    )
+                else:
+                    handler.setFormatter(
+                        color_detailed_formatter if log_level == logging.DEBUG else color_simple_formatter
+                    )
             add_file_handler_if_needed(logger, log_file, file_mode, log_level)
         return logger
 
@@ -66,7 +92,11 @@ def get_logger(log_file: Optional[str] = None, log_level: int = DEFAULT_LEVEL, f
         handlers.append(file_handler)
 
     for handler in handlers:
-        handler.setFormatter(detailed_formatter if log_level == logging.DEBUG else simple_formatter)
+        # 区分不同类型的 handler，使用相应的格式化器
+        if isinstance(handler, logging.FileHandler):
+            handler.setFormatter(plain_detailed_formatter if log_level == logging.DEBUG else plain_simple_formatter)
+        else:
+            handler.setFormatter(color_detailed_formatter if log_level == logging.DEBUG else color_simple_formatter)
         handler.setLevel(log_level)
         logger.addHandler(handler)
 
@@ -102,6 +132,15 @@ def add_file_handler_if_needed(logger, log_file, file_mode, log_level):
 
     if is_worker0 and log_file is not None:
         file_handler = logging.FileHandler(log_file, file_mode)
-        file_handler.setFormatter(detailed_formatter if log_level == logging.DEBUG else simple_formatter)
+        file_handler.setFormatter(plain_detailed_formatter if log_level == logging.DEBUG else plain_simple_formatter)
         file_handler.setLevel(log_level)
         logger.addHandler(file_handler)
+
+
+def warn_once(logger: Logger, message: str) -> None:
+    if message not in _warned:
+        logger.warning(message)
+        _warned.append(message)
+
+
+_warned: List[str] = []

evalscope/utils/model_utils.py

@@ -1,10 +1,10 @@
 import numpy as np
-import os
 import random
-import torch
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
 
+from evalscope.utils.import_utils import check_import
+
 if TYPE_CHECKING:
     from transformers import GenerationConfig
 
@@ -69,8 +69,12 @@ def seed_everything(seed: int):
     """
     random.seed(seed)
     np.random.seed(seed)
-    torch.manual_seed(seed)
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(seed)
-        torch.backends.cudnn.deterministic = True
-        torch.backends.cudnn.benchmark = False
+
+    if check_import('torch'):
+        import torch
+
+        torch.manual_seed(seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed_all(seed)
+            torch.backends.cudnn.deterministic = True
+            torch.backends.cudnn.benchmark = False

evalscope/utils/multi_choices.py

@@ -0,0 +1,288 @@
+# flake8: noqa: E501
+import re
+from typing import List, Optional, Union
+
+from evalscope.api.evaluator import Choices, Target, TaskState
+
+FEW_SHOT_TEMPLATE = r"""Here are some examples of how to answer similar questions:
+
+{fewshot}
+
+""".lstrip()
+
+CHINESE_FEW_SHOT_TEMPLATE = r"""以下是一些示例问题：
+
+{fewshot}
+
+""".lstrip()
+
+CHINESE_SINGLE_ANSWER_TEMPLATE = r"""回答下面的单项选择题，请选出其中的正确答案。你的回答的最后一行应该是这样的格式："答案：LETTER"（不带引号），其中 LETTER 是 {letters} 中的一个。
+
+问题：{question}
+选项：
+{choices}
+""".lstrip()
+
+CHINESE_SINGLE_ANSWER_TEMPLATE_COT = r"""回答下面的单项选择题，请选出其中的正确答案。你的回答的最后一行应该是这样的格式："答案：LETTER"（不带引号），其中 LETTER 是 {letters} 中的一个。请在回答前进行一步步思考。
+
+问题：{question}
+选项：
+{choices}
+""".lstrip()
+
+SINGLE_ANSWER_TEMPLATE = r"""
+Answer the following multiple choice question. The entire content of your response should be of the following format: 'ANSWER: $LETTER' (without quotes) where LETTER is one of {letters}.
+
+{question}
+
+{choices}
+""".strip()
+
+SINGLE_ANSWER_TEMPLATE_COT = r"""
+Answer the following multiple choice question. The last line of your response should be of the following format: 'ANSWER: $LETTER' (without quotes) where LETTER is one of {letters}. Think step by step before answering.
+
+{question}
+
+{choices}
+""".strip()
+
+MULTIPLE_ANSWER_TEMPLATE = r"""
+Answer the following multiple choice question where multiple answers may be correct. The entire content of your response should be of the following format: 'ANSWER: $LETTERS' (without quotes) where LETTERS is one or more of {letters}.
+
+{question}
+
+{choices}
+""".strip()
+
+MULTIPLE_ANSWER_TEMPLATE_COT = r"""
+Answer the following multiple choice question where multiple answers may be correct. The last line of your response should be of the following format: 'ANSWER: $LETTERS' (without quotes) where LETTERS is one or more of {letters}. Think step by step before answering.
+
+{question}
+
+{choices}
+""".strip()
+
+
+def unshuffle_choices(choices: Choices) -> Choices:
+    # `sorted` returns `list[Choice]`, but for consistency we wrap this back
+    # into a `Choices` object
+    return Choices(sorted(choices, key=lambda choice: choice.original_position))
+
+
+def answer_options(choices: Choices) -> str:
+    r"""
+    Returns the `choices` formatted as a multiple choice question, e.g.:
+
+    ["choice 1", "choice 2", "choice 3"] ->
+        "A) choice 1\nB) choice 2\nC) choice 3"
+    """
+    indexes = list(range(len(choices)))
+
+    return '\n'.join([f'{answer_character(i)}) {choices[j].value}' for i, j in enumerate(indexes)])
+
+
+def prompt(question: str, choices: Union[Choices, List[str]], template: str, fewshot: Optional[str] = None) -> str:
+    if isinstance(choices, list):
+        choices = Choices(choices)
+
+    choices_text = answer_options(choices)
+    letters = ','.join(answer_character(i) for i in range(len(choices)))
+    if not fewshot:
+        return template.format(
+            choices=choices_text,
+            letters=letters,
+            question=question,
+        )
+    else:
+        return template.format(
+            choices=choices_text,
+            letters=letters,
+            question=question,
+            fewshot=fewshot,
+        )
+
+
+def format_example(
+    question: str,
+    choices: Choices,
+    answer: Target,
+) -> str:
+    """Format a single example for few-shot learning.
+
+    Args:
+        question (str): The question text.
+        choices (list[str]): The list of choices.
+        answer (list[str]): The correct answers.
+
+    Returns:
+        str: Formatted example string.
+    """
+    choices_text = answer_options(choices)
+    return f'{question}\n{choices_text}\nANSWER: {answer.text}'
+
+
+def _fallback_parse_answer(completion: str) -> Optional[set[str]]:
+    # Fallback to find the last upper case letter
+    for letter in reversed(completion):
+        if letter.isupper():
+            return {letter}
+    return None
+
+
+def parse_answers(state: TaskState, multiple_correct: bool = False) -> set[str]:
+    """
+    Convenience function for extracting answers from the state output.
+
+    The generated response must be in the format 'ANSWER: <answers>',
+    otherwise we can't extract what the model thinks is "true". We can be a
+    bit flexible whether these are "AB" vs "A,B" vs "A B".
+
+    However, if the answer isn't in the expected format the model has
+    failed in the task so we'll ultimately just mark it as incorrect
+    """
+    # First check whether the string strictly ends with the expected answer
+    # In this case, we're looking for a single line which contains the expected
+    # ANSWER: <answer> string with only whitespace or a period/full stop at the end.
+    match = re.search(
+        r'(?i)^ANSWER\s*:\s*([A-Za-z\d ,]+)\s*(?:$|\n|\.)',
+        state.output.completion,
+        flags=re.MULTILINE,
+    )
+
+    # If we couldn't match the strict version, we can try the less strict
+    # version for backward compatibility
+    if match is None:
+        match = re.search(
+            r'(?i)ANSWER\s*:\s*([A-Za-z\d ,]+)(?:[^\w]|\n|$|\.)',
+            state.output.completion,
+        )
+
+    if match is None:
+        fallback_answer = _fallback_parse_answer(state.output.completion)
+        if fallback_answer:
+            return fallback_answer
+
+    if match is None:
+        return set()
+
+    matched = match.group(1)
+
+    # Strip trailing period / full stop
+    matched = matched.strip()
+    matched = matched.rstrip('.')
+
+    allowed_options = set(answer_character(i) for i in range(len(state.choices)))
+
+    if multiple_correct:
+        # Match must contain only the allowed choices
+        # (may be separated by commas, spaces, the word 'and', or nothing at all)
+
+        matched = matched.replace(' and ', '')
+
+        matched = matched.replace(' ', '')
+
+        split_comma = set(matched.split(','))
+        if split_comma.issubset(allowed_options):
+            answers = split_comma
+            return answers
+
+        split_nothing = set(matched)
+        if split_nothing.issubset(allowed_options):
+            answers = split_nothing
+            return answers
+
+    else:
+        # Match must contain a single letter in the allowed choices
+        if matched in allowed_options:
+            answers = {matched}
+            return answers
+
+    return set()
+
+
+def parse_answers_zh(state: TaskState, multiple_correct: bool = False) -> set[str]:
+    """
+    Convenience function for extracting answers from the state output in Chinese format.
+
+    The generated response must be in the format '答案：选项',
+    otherwise we can't extract what the model thinks is "true". We can be a
+    bit flexible whether these are "AB" vs "A,B" vs "A B".
+    """
+    # Simple pattern to capture answers with optional bold markdown
+    pattern = r'答案\s*[:：]\s*([A-Za-z0-9,，]+)'
+    match = re.search(pattern, state.output.completion, flags=re.MULTILINE)
+
+    if match is None:
+        fallback_answer = _fallback_parse_answer(state.output.completion)
+        if fallback_answer:
+            return fallback_answer
+
+    if match is None:
+        return set()
+
+    matched = match.group(1).strip().rstrip('。.')
+    allowed_options = set(answer_character(i) for i in range(len(state.choices)))
+
+    if multiple_correct:
+        # Handle comma-separated or continuous letters
+        matched = matched.replace(' 和 ', '').replace(' ', '').replace('，', ',')
+        answers = set(matched.split(',')) if ',' in matched else set(matched)
+        return answers if answers.issubset(allowed_options) else set()
+    else:
+        # Single answer
+        return {matched} if matched in allowed_options else set()
+
+
+def set_choices_based_on_generated_response(state: TaskState, answers: set[str]) -> None:
+    true_answers = [answer_index(letter) for letter in answers]
+
+    for i in range(len(state.choices)):
+        if i in true_answers:
+            state.choices.mark_choice(i, True)
+        else:
+            state.choices.mark_choice(i, False)
+
+
+def valid_template(template: str) -> bool:
+    """Check if a template has the required capture groups for a multiple choice question"""
+    return bool(re.search(r'\{question\}', template) and re.search(r'\{choices\}', template))
+
+
+class MultipleChoiceTemplate:
+    """
+    Templates for multiple choice questions.
+    """
+
+    SINGLE_ANSWER = SINGLE_ANSWER_TEMPLATE
+    SINGLE_ANSWER_COT = SINGLE_ANSWER_TEMPLATE_COT
+    MULTIPLE_ANSWER = MULTIPLE_ANSWER_TEMPLATE
+    MULTIPLE_ANSWER_COT = MULTIPLE_ANSWER_TEMPLATE_COT
+    CHINESE_FEW_SHOT_TEMPLATE = CHINESE_FEW_SHOT_TEMPLATE
+    CHINESE_SINGLE_ANSWER_TEMPLATE = CHINESE_SINGLE_ANSWER_TEMPLATE
+    CHINESE_SINGLE_ANSWER_TEMPLATE_COT = CHINESE_SINGLE_ANSWER_TEMPLATE_COT
+
+
+def answer_character(index: int) -> str:
+    r"""
+    Helper to go from array index to char, for example:
+
+        0 -> 'A', 1 -> 'B', etc
+    """
+    if index < 26:
+        return chr(ord('A') + index)
+    else:
+        return str(index - 25)
+
+
+def answer_index(char: str) -> int:
+    r"""
+    Helper to go from char to array index, for example:
+
+        'A' -> 0, 'B' -> 1, etc
+    """
+    if char.isalpha() or char == ',' or char == ' ':
+        return ord(char.upper()) - ord('A')
+    elif char.isnumeric():
+        return 25 + int(char)
+    else:
+        raise ValueError(f'Unepxected multiple choice answer: {char} (must be a letter or number)')

evalscope/utils/url_utils.py

@@ -0,0 +1,65 @@
+import base64
+import httpx
+import mimetypes
+import re
+
+
+def is_http_url(url: str) -> bool:
+    return url.startswith('http://') or url.startswith('https://')
+
+
+def is_data_uri(url: str) -> bool:
+    pattern = r'^data:([^;]+);base64,.*'
+    return re.match(pattern, url) is not None
+
+
+def data_uri_mime_type(data_url: str) -> str | None:
+    pattern = r'^data:([^;]+);.*'
+    match = re.match(pattern, data_url)
+    if match:
+        mime_type = match.group(1)
+        return mime_type
+    else:
+        return None
+
+
+def data_uri_to_base64(data_uri: str) -> str:
+    pattern = r'^data:[^,]+,'
+    stripped_uri = re.sub(pattern, '', data_uri)
+    return stripped_uri
+
+
+def file_as_data(file: str) -> tuple[bytes, str]:
+    if is_data_uri(file):
+        # resolve mime type and base64 content
+        mime_type = data_uri_mime_type(file) or 'image/png'
+        file_base64 = data_uri_to_base64(file)
+        file_bytes = base64.b64decode(file_base64)
+    else:
+        # guess mime type; need strict=False for webp images
+        type, _ = mimetypes.guess_type(file, strict=False)
+        if type:
+            mime_type = type
+        else:
+            mime_type = 'image/png'
+
+        # handle url or file
+        if is_http_url(file):
+            client = httpx.Client()
+            file_bytes = client.get(file).content
+        else:
+            with open(file, 'rb') as f:
+                file_bytes = f.read()
+
+    # return bytes and type
+    return file_bytes, mime_type
+
+
+def file_as_data_uri(file: str) -> str:
+    if is_data_uri(file):
+        return file
+    else:
+        bytes, mime_type = file_as_data(file)
+        base64_file = base64.b64encode(bytes).decode('utf-8')
+        file = f'data:{mime_type};base64,{base64_file}'
+        return file