lionagi 0.14.9__py3-none-any.whl → 0.14.10__py3-none-any.whl

lionagi/utils.py

@@ -14,9 +14,7 @@ import re
 import shutil
 import subprocess
 import sys
-import time as t_
 import uuid
-import xml.etree.ElementTree as ET
 from abc import ABC
 from collections.abc import (
     AsyncGenerator,
@@ -27,7 +25,6 @@ from collections.abc import (
 )
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
-from decimal import Decimal
 from enum import Enum
 from functools import lru_cache, partial
 from inspect import isclass
@@ -43,11 +40,12 @@ from typing import (
 )
 
 import anyio
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel
 from pydantic_core import PydanticUndefinedType
 
 from .libs.concurrency import Lock as ConcurrencyLock
 from .libs.concurrency import Semaphore, create_task_group
+from .libs.validate.xml_parser import xml_to_dict
 from .settings import Settings
 
 R = TypeVar("R")
@@ -89,7 +87,6 @@ __all__ = (
     "throttle",
     "max_concurrent",
     "force_async",
-    "to_num",
     "breakdown_pydantic_annotation",
     "run_package_manager_command",
     "StringEnum",
@@ -473,24 +470,6 @@ def to_list(
     return processed
 
 
-class ToListParams(Params):
-    flatten: bool = False
-    dropna: bool = False
-    unique: bool = False
-    use_values: bool = False
-    flatten_tuple_set: bool = False
-
-    def __call__(self, input_: Any):
-        return to_list(
-            input_,
-            flatten=self.flatten,
-            dropna=self.dropna,
-            unique=self.unique,
-            use_values=self.use_values,
-            flatten_tuple_set=self.flatten_tuple_set,
-        )
-
-
 def lcall(
     input_: Iterable[T] | T,
     func: Callable[[T], R] | Iterable[Callable[[T], R]],
@@ -598,29 +577,6 @@ def lcall(
     return out
 
 
-class CallParams(Params):
-    """params class for high order function with additional handling of lower order function parameters, can take arbitrary number of args and kwargs, args need to be in agrs=, kwargs can be passed as is"""
-
-    args: list = []
-    kwargs: dict = {}
-
-    @model_validator(mode="before")
-    def _validate_data(cls, data: dict):
-        _d = {}
-        for k in list(data.keys()):
-            if k in cls.keys():
-                _d[k] = data.pop(k)
-        _d.setdefault("args", [])
-        _d.setdefault("kwargs", {})
-        _d["kwargs"].update(data)
-        return _d
-
-    def __call__(self, *args, **kwargs):
-        raise NotImplementedError(
-            "This method should be implemented in a subclass"
-        )
-
-
 async def alcall(
     input_: list[Any],
     func: Callable[..., T],
@@ -933,92 +889,6 @@ def create_path(
     return full_path
 
 
-class CreatePathParams(Params):
-    directory: Path | str
-    filename: str
-    extension: str = None
-    timestamp: bool = False
-    dir_exist_ok: bool = True
-    file_exist_ok: bool = False
-    time_prefix: bool = False
-    timestamp_format: str | None = None
-    random_hash_digits: int = 0
-
-    def __call__(
-        self, directory: Path | str = None, filename: str = None
-    ) -> Path:
-        return create_path(
-            directory or self.directory,
-            filename or self.filename,
-            extension=self.extension,
-            timestamp=self.timestamp,
-            dir_exist_ok=self.dir_exist_ok,
-            file_exist_ok=self.file_exist_ok,
-            time_prefix=self.time_prefix,
-            timestamp_format=self.timestamp_format,
-            random_hash_digits=self.random_hash_digits,
-        )
-
-
-# --- JSON and XML Conversion ---
-
-
-def to_xml(
-    obj: dict | list | str | int | float | bool | None,
-    root_name: str = "root",
-) -> str:
-    """
-    Convert a dictionary into an XML formatted string.
-
-    Rules:
-    - A dictionary key becomes an XML tag.
-    - If the dictionary value is:
-      - A primitive type (str, int, float, bool, None): it becomes the text content of the tag.
-      - A list: each element of the list will repeat the same tag.
-      - Another dictionary: it is recursively converted to nested XML.
-    - root_name sets the top-level XML element name.
-
-    Args:
-        obj: The Python object to convert (typically a dictionary).
-        root_name: The name of the root XML element.
-
-    Returns:
-        A string representing the XML.
-
-    Examples:
-        >>> to_xml({"a": 1, "b": {"c": "hello", "d": [10, 20]}}, root_name="data")
-        '<data><a>1</a><b><c>hello</c><d>10</d><d>20</d></b></data>'
-    """
-
-    def _convert(value: Any, tag_name: str) -> str:
-        # If value is a dict, recursively convert its keys
-        if isinstance(value, dict):
-            inner = "".join(_convert(v, k) for k, v in value.items())
-            return f"<{tag_name}>{inner}</{tag_name}>"
-        # If value is a list, repeat the same tag for each element
-        elif isinstance(value, list):
-            return "".join(_convert(item, tag_name) for item in value)
-        # If value is a primitive, convert to string and place inside tag
-        else:
-            text = "" if value is None else str(value)
-            # Escape special XML characters if needed (minimal)
-            text = (
-                text.replace("&", "&amp;")
-                .replace("<", "&lt;")
-                .replace(">", "&gt;")
-                .replace('"', "&quot;")
-                .replace("'", "&apos;")
-            )
-            return f"<{tag_name}>{text}</{tag_name}>"
-
-    # If top-level obj is not a dict, wrap it in one
-    if not isinstance(obj, dict):
-        obj = {root_name: obj}
-
-    inner_xml = "".join(_convert(v, k) for k, v in obj.items())
-    return f"<{root_name}>{inner_xml}</{root_name}>"
-
-
 def fuzzy_parse_json(
     str_to_parse: str, /
 ) -> dict[str, Any] | list[dict[str, Any]]:
@@ -1132,148 +1002,6 @@ def fix_json_string(str_to_parse: str, /) -> str:
     return str_to_parse
 
 
-class XMLParser:
-    def __init__(self, xml_string: str):
-        self.xml_string = xml_string.strip()
-        self.index = 0
-
-    def parse(self) -> dict[str, Any]:
-        """Parse the XML string and return the root element as a dictionary."""
-        return self._parse_element()
-
-    def _parse_element(self) -> dict[str, Any]:
-        """Parse a single XML element and its children."""
-        self._skip_whitespace()
-        if self.xml_string[self.index] != "<":
-            raise ValueError(
-                f"Expected '<', found '{self.xml_string[self.index]}'"
-            )
-
-        tag, attributes = self._parse_opening_tag()
-        children: dict[str, str | list | dict] = {}
-        text = ""
-
-        while self.index < len(self.xml_string):
-            self._skip_whitespace()
-            if self.xml_string.startswith("</", self.index):
-                closing_tag = self._parse_closing_tag()
-                if closing_tag != tag:
-                    raise ValueError(
-                        f"Mismatched tags: '{tag}' and '{closing_tag}'"
-                    )
-                break
-            elif self.xml_string.startswith("<", self.index):
-                child = self._parse_element()
-                child_tag, child_data = next(iter(child.items()))
-                if child_tag in children:
-                    if not isinstance(children[child_tag], list):
-                        children[child_tag] = [children[child_tag]]
-                    children[child_tag].append(child_data)
-                else:
-                    children[child_tag] = child_data
-            else:
-                text += self._parse_text()
-
-        result: dict[str, Any] = {}
-        if attributes:
-            result["@attributes"] = attributes
-        if children:
-            result.update(children)
-        elif text.strip():
-            result = text.strip()
-
-        return {tag: result}
-
-    def _parse_opening_tag(self) -> tuple[str, dict[str, str]]:
-        """Parse an opening XML tag and its attributes."""
-        match = re.match(
-            r'<(\w+)((?:\s+\w+="[^"]*")*)\s*/?>',
-            self.xml_string[self.index :],  # noqa
-        )
-        if not match:
-            raise ValueError("Invalid opening tag")
-        self.index += match.end()
-        tag = match.group(1)
-        attributes = dict(re.findall(r'(\w+)="([^"]*)"', match.group(2)))
-        return tag, attributes
-
-    def _parse_closing_tag(self) -> str:
-        """Parse a closing XML tag."""
-        match = re.match(r"</(\w+)>", self.xml_string[self.index :])  # noqa
-        if not match:
-            raise ValueError("Invalid closing tag")
-        self.index += match.end()
-        return match.group(1)
-
-    def _parse_text(self) -> str:
-        """Parse text content between XML tags."""
-        start = self.index
-        while (
-            self.index < len(self.xml_string)
-            and self.xml_string[self.index] != "<"
-        ):
-            self.index += 1
-        return self.xml_string[start : self.index]  # noqa
-
-    def _skip_whitespace(self) -> None:
-        """Skip any whitespace characters at the current parsing position."""
-        p_ = len(self.xml_string[self.index :])  # noqa
-        m_ = len(self.xml_string[self.index :].lstrip())  # noqa
-
-        self.index += p_ - m_
-
-
-def xml_to_dict(
-    xml_string: str,
-    /,
-    suppress=False,
-    remove_root: bool = True,
-    root_tag: str = None,
-) -> dict[str, Any]:
-    """
-    Parse an XML string into a nested dictionary structure.
-
-    This function converts an XML string into a dictionary where:
-    - Element tags become dictionary keys
-    - Text content is assigned directly to the tag key if there are no children
-    - Attributes are stored in a '@attributes' key
-    - Multiple child elements with the same tag are stored as lists
-
-    Args:
-        xml_string: The XML string to parse.
-
-    Returns:
-        A dictionary representation of the XML structure.
-
-    Raises:
-        ValueError: If the XML is malformed or parsing fails.
-    """
-    try:
-        a = XMLParser(xml_string).parse()
-        if remove_root and (root_tag or "root") in a:
-            a = a[root_tag or "root"]
-        return a
-    except ValueError as e:
-        if not suppress:
-            raise e
-
-
-def dict_to_xml(data: dict, /, root_tag: str = "root") -> str:
-    root = ET.Element(root_tag)
-
-    def convert(dict_obj: dict, parent: Any) -> None:
-        for key, val in dict_obj.items():
-            if isinstance(val, dict):
-                element = ET.SubElement(parent, key)
-                convert(dict_obj=val, parent=element)
-            else:
-                element = ET.SubElement(parent, key)
-                element.text = str(object=val)
-
-    convert(dict_obj=data, parent=root)
-    return ET.tostring(root, encoding="unicode")
-
-
 def to_dict(
     input_: Any,
     /,
@@ -1677,74 +1405,6 @@ def get_bins(input_: list[str], upper: int) -> list[list[int]]:
     return bins
 
 
-class Throttle:
-    """
-    Provide a throttling mechanism for function calls.
-
-    When used as a decorator, it ensures that the decorated function can only
-    be called once per specified period. Subsequent calls within this period
-    are delayed to enforce this constraint.
-
-    Attributes:
-        period: The minimum time period (in seconds) between successive calls.
-    """
-
-    def __init__(self, period: float) -> None:
-        """
-        Initialize a new instance of Throttle.
-
-        Args:
-            period: The minimum time period (in seconds) between
-                successive calls.
-        """
-        self.period = period
-        self.last_called = 0
-
-    def __call__(self, func: Callable[..., T]) -> Callable[..., T]:
-        """
-        Decorate a synchronous function with the throttling mechanism.
-
-        Args:
-            func: The synchronous function to be throttled.
-
-        Returns:
-            The throttled synchronous function.
-        """
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs) -> Any:
-            elapsed = time() - self.last_called
-            if elapsed < self.period:
-                t_.sleep(self.period - elapsed)
-            self.last_called = time()
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    def __call_async__(
-        self, func: Callable[..., Callable[..., T]]
-    ) -> Callable[..., Callable[..., T]]:
-        """
-        Decorate an asynchronous function with the throttling mechanism.
-
-        Args:
-            func: The asynchronous function to be throttled.
-
-        Returns:
-            The throttled asynchronous function.
-        """
-
-        @functools.wraps(func)
-        async def wrapper(*args, **kwargs) -> Any:
-            elapsed = time() - self.last_called
-            if elapsed < self.period:
-                await asyncio.sleep(self.period - elapsed)
-            self.last_called = time()
-            return await func(*args, **kwargs)
-
-        return wrapper
-
-
 def force_async(fn: Callable[..., T]) -> Callable[..., Callable[..., T]]:
     """
     Convert a synchronous function to an asynchronous function
@@ -1779,6 +1439,8 @@ def throttle(
     Returns:
         The throttled function.
     """
+    from lionagi.libs.concurrency.throttle import Throttle
+
     if not is_coro_func(func):
         func = force_async(func)
     throttle_instance = Throttle(period)
@@ -1816,380 +1478,6 @@ def max_concurrent(
     return wrapper
 
 
-# Type definitions
-NUM_TYPE_LITERAL = Literal["int", "float", "complex"]
-NUM_TYPES = type[int] | type[float] | type[complex] | NUM_TYPE_LITERAL
-NumericType = TypeVar("NumericType", int, float, complex)
-
-# Type mapping
-TYPE_MAP = {"int": int, "float": float, "complex": complex}
-
-# Regex patterns for different numeric formats
-PATTERNS = {
-    "scientific": r"[-+]?(?:\d*\.)?\d+[eE][-+]?\d+",
-    "complex_sci": r"[-+]?(?:\d*\.)?\d+(?:[eE][-+]?\d+)?[-+](?:\d*\.)?\d+(?:[eE][-+]?\d+)?[jJ]",
-    "complex": r"[-+]?(?:\d*\.)?\d+[-+](?:\d*\.)?\d+[jJ]",
-    "pure_imaginary": r"[-+]?(?:\d*\.)?\d*[jJ]",
-    "percentage": r"[-+]?(?:\d*\.)?\d+%",
-    "fraction": r"[-+]?\d+/\d+",
-    "decimal": r"[-+]?(?:\d*\.)?\d+",
-    "special": r"[-+]?(?:inf|infinity|nan)",
-}
-
-
-def to_num(
-    input_: Any,
-    /,
-    *,
-    upper_bound: int | float | None = None,
-    lower_bound: int | float | None = None,
-    num_type: NUM_TYPES = float,
-    precision: int | None = None,
-    num_count: int = 1,
-) -> int | float | complex | list[int | float | complex]:
-    """Convert input to numeric type(s) with validation and bounds checking.
-
-    Args:
-        input_value: The input to convert to number(s).
-        upper_bound: Maximum allowed value (inclusive).
-        lower_bound: Minimum allowed value (inclusive).
-        num_type: Target numeric type ('int', 'float', 'complex' or type objects).
-        precision: Number of decimal places for rounding (float only).
-        num_count: Number of numeric values to extract.
-
-    Returns:
-        Converted number(s). Single value if num_count=1, else list.
-
-    Raises:
-        ValueError: For invalid input or out of bounds values.
-        TypeError: For invalid input types or invalid type conversions.
-    """
-    # Validate input
-    if isinstance(input_, (list, tuple)):
-        raise TypeError("Input cannot be a sequence")
-
-    # Handle boolean input
-    if isinstance(input_, bool):
-        return validate_num_type(num_type)(input_)
-
-    # Handle direct numeric input
-    if isinstance(input_, (int, float, complex, Decimal)):
-        inferred_type = type(input_)
-        if isinstance(input_, Decimal):
-            inferred_type = float
-        value = float(input_) if not isinstance(input_, complex) else input_
-        value = apply_bounds(value, upper_bound, lower_bound)
-        value = apply_precision(value, precision)
-        return convert_type(value, validate_num_type(num_type), inferred_type)
-
-    # Convert input to string and extract numbers
-    input_str = str(input_)
-    number_matches = extract_numbers(input_str)
-
-    if not number_matches:
-        raise ValueError(f"No valid numbers found in: {input_str}")
-
-    # Process numbers
-    results = []
-    target_type = validate_num_type(num_type)
-
-    number_matches = (
-        number_matches[:num_count]
-        if num_count < len(number_matches)
-        else number_matches
-    )
-
-    for type_and_value in number_matches:
-        try:
-            # Infer appropriate type
-            inferred_type = infer_type(type_and_value)
-
-            # Parse to numeric value
-            value = parse_number(type_and_value)
-
-            # Apply bounds if not complex
-            value = apply_bounds(value, upper_bound, lower_bound)
-
-            # Apply precision
-            value = apply_precision(value, precision)
-
-            # Convert to target type if different from inferred
-            value = convert_type(value, target_type, inferred_type)
-
-            results.append(value)
-
-        except Exception as e:
-            if len(type_and_value) == 2:
-                raise type(e)(
-                    f"Error processing {type_and_value[1]}: {str(e)}"
-                )
-            raise type(e)(f"Error processing {type_and_value}: {str(e)}")
-
-    if results and num_count == 1:
-        return results[0]
-    return results
-
-
-def extract_numbers(text: str) -> list[tuple[str, str]]:
-    """Extract numeric values from text using ordered regex patterns.
-
-    Args:
-        text: The text to extract numbers from.
-
-    Returns:
-        List of tuples containing (pattern_type, matched_value).
-    """
-    combined_pattern = "|".join(PATTERNS.values())
-    matches = re.finditer(combined_pattern, text, re.IGNORECASE)
-    numbers = []
-
-    for match in matches:
-        value = match.group()
-        # Check which pattern matched
-        for pattern_name, pattern in PATTERNS.items():
-            if re.fullmatch(pattern, value, re.IGNORECASE):
-                numbers.append((pattern_name, value))
-                break
-
-    return numbers
-
-
-def validate_num_type(num_type: NUM_TYPES) -> type:
-    """Validate and normalize numeric type specification.
-
-    Args:
-        num_type: The numeric type to validate.
-
-    Returns:
-        The normalized Python type object.
-
-    Raises:
-        ValueError: If the type specification is invalid.
-    """
-    if isinstance(num_type, str):
-        if num_type not in TYPE_MAP:
-            raise ValueError(f"Invalid number type: {num_type}")
-        return TYPE_MAP[num_type]
-
-    if num_type not in (int, float, complex):
-        raise ValueError(f"Invalid number type: {num_type}")
-    return num_type
-
-
-def infer_type(value: tuple[str, str]) -> type:
-    """Infer appropriate numeric type from value.
-
-    Args:
-        value: Tuple of (pattern_type, matched_value).
-
-    Returns:
-        The inferred Python type.
-    """
-    pattern_type, _ = value
-    if pattern_type in ("complex", "complex_sci", "pure_imaginary"):
-        return complex
-    return float
-
-
-def convert_special(value: str) -> float:
-    """Convert special float values (inf, -inf, nan).
-
-    Args:
-        value: The string value to convert.
-
-    Returns:
-        The converted float value.
-    """
-    value = value.lower()
-    if "infinity" in value or "inf" in value:
-        return float("-inf") if value.startswith("-") else float("inf")
-    return float("nan")
-
-
-def convert_percentage(value: str) -> float:
-    """Convert percentage string to float.
-
-    Args:
-        value: The percentage string to convert.
-
-    Returns:
-        The converted float value.
-
-    Raises:
-        ValueError: If the percentage value is invalid.
-    """
-    try:
-        return float(value.rstrip("%")) / 100
-    except ValueError as e:
-        raise ValueError(f"Invalid percentage value: {value}") from e
-
-
-def convert_complex(value: str) -> complex:
-    """Convert complex number string to complex.
-
-    Args:
-        value: The complex number string to convert.
-
-    Returns:
-        The converted complex value.
-
-    Raises:
-        ValueError: If the complex number is invalid.
-    """
-    try:
-        # Handle pure imaginary numbers
-        if value.endswith("j") or value.endswith("J"):
-            if value in ("j", "J"):
-                return complex(0, 1)
-            if value in ("+j", "+J"):
-                return complex(0, 1)
-            if value in ("-j", "-J"):
-                return complex(0, -1)
-            if "+" not in value and "-" not in value[1:]:
-                # Pure imaginary number
-                imag = float(value[:-1] or "1")
-                return complex(0, imag)
-
-        return complex(value.replace(" ", ""))
-    except ValueError as e:
-        raise ValueError(f"Invalid complex number: {value}") from e
-
-
-def convert_type(
-    value: float | complex,
-    target_type: type,
-    inferred_type: type,
-) -> int | float | complex:
-    """Convert value to target type if specified, otherwise use inferred type.
-
-    Args:
-        value: The value to convert.
-        target_type: The requested target type.
-        inferred_type: The inferred type from the value.
-
-    Returns:
-        The converted value.
-
-    Raises:
-        TypeError: If the conversion is not possible.
-    """
-    try:
-        # If no specific type requested, use inferred type
-        if target_type is float and inferred_type is complex:
-            return value
-
-        # Handle explicit type conversions
-        if target_type is int and isinstance(value, complex):
-            raise TypeError("Cannot convert complex number to int")
-        return target_type(value)
-    except (ValueError, TypeError) as e:
-        raise TypeError(
-            f"Cannot convert {value} to {target_type.__name__}"
-        ) from e
-
-
-def apply_bounds(
-    value: float | complex,
-    upper_bound: float | None = None,
-    lower_bound: float | None = None,
-) -> float | complex:
-    """Apply bounds checking to numeric value.
-
-    Args:
-        value: The value to check.
-        upper_bound: Maximum allowed value (inclusive).
-        lower_bound: Minimum allowed value (inclusive).
-
-    Returns:
-        The validated value.
-
-    Raises:
-        ValueError: If the value is outside bounds.
-    """
-    if isinstance(value, complex):
-        return value
-
-    if upper_bound is not None and value > upper_bound:
-        raise ValueError(f"Value {value} exceeds upper bound {upper_bound}")
-    if lower_bound is not None and value < lower_bound:
-        raise ValueError(f"Value {value} below lower bound {lower_bound}")
-    return value
-
-
-def apply_precision(
-    value: float | complex,
-    precision: int | None,
-) -> float | complex:
-    """Apply precision rounding to numeric value.
-
-    Args:
-        value: The value to round.
-        precision: Number of decimal places.
-
-    Returns:
-        The rounded value.
-    """
-    if precision is None or isinstance(value, complex):
-        return value
-    if isinstance(value, float):
-        return round(value, precision)
-    return value
-
-
-def parse_number(type_and_value: tuple[str, str]) -> float | complex:
-    """Parse string to numeric value based on pattern type.
-
-    Args:
-        type_and_value: Tuple of (pattern_type, matched_value).
-
-    Returns:
-        The parsed numeric value.
-
-    Raises:
-        ValueError: If parsing fails.
-    """
-    num_type, value = type_and_value
-    value = value.strip()
-
-    try:
-        if num_type == "special":
-            return convert_special(value)
-
-        if num_type == "percentage":
-            return convert_percentage(value)
-
-        if num_type == "fraction":
-            if "/" not in value:
-                raise ValueError(f"Invalid fraction: {value}")
-            if value.count("/") > 1:
-                raise ValueError(f"Invalid fraction: {value}")
-            num, denom = value.split("/")
-            if not (num.strip("-").isdigit() and denom.isdigit()):
-                raise ValueError(f"Invalid fraction: {value}")
-            denom_val = float(denom)
-            if denom_val == 0:
-                raise ValueError("Division by zero")
-            return float(num) / denom_val
-        if num_type in ("complex", "complex_sci", "pure_imaginary"):
-            return convert_complex(value)
-        if num_type == "scientific":
-            if "e" not in value.lower():
-                raise ValueError(f"Invalid scientific notation: {value}")
-            parts = value.lower().split("e")
-            if len(parts) != 2:
-                raise ValueError(f"Invalid scientific notation: {value}")
-            if not (parts[1].lstrip("+-").isdigit()):
-                raise ValueError(f"Invalid scientific notation: {value}")
-            return float(value)
-        if num_type == "decimal":
-            return float(value)
-
-        raise ValueError(f"Unknown number type: {num_type}")
-    except Exception as e:
-        # Preserve the specific error type but wrap with more context
-        raise type(e)(f"Failed to parse {value} as {num_type}: {str(e)}")
-
-
 def breakdown_pydantic_annotation(
     model: type[B], max_depth: int | None = None, current_depth: int = 0
 ) -> dict[str, Any]:
@@ -2409,60 +1697,3 @@ def is_import_installed(package_name: str) -> bool:
         bool: True if the package is installed, False otherwise.
     """
     return importlib.util.find_spec(package_name) is not None
-
-
-def read_image_to_base64(image_path: str | Path) -> str:
-    import base64
-
-    import cv2
-
-    image_path = str(image_path)
-    image = cv2.imread(image_path, cv2.COLOR_BGR2RGB)
-
-    if image is None:
-        raise ValueError(f"Could not read image from path: {image_path}")
-
-    file_extension = "." + image_path.split(".")[-1]
-
-    success, buffer = cv2.imencode(file_extension, image)
-    if not success:
-        raise ValueError(f"Could not encode image to {file_extension} format.")
-    encoded_image = base64.b64encode(buffer).decode("utf-8")
-    return encoded_image
-
-
-def pdf_to_images(
-    pdf_path: str, output_folder: str, dpi: int = 300, fmt: str = "jpeg"
-) -> list:
-    """
-    Convert a PDF file into images, one image per page.
-
-    Args:
-        pdf_path (str): Path to the input PDF file.
-        output_folder (str): Directory to save the output images.
-        dpi (int): Dots per inch (resolution) for conversion (default: 300).
-        fmt (str): Image format (default: 'jpeg'). Use 'png' if preferred.
-
-    Returns:
-        list: A list of file paths for the saved images.
-    """
-    import os
-
-    convert_from_path = check_import(
-        "pdf2image", import_name="convert_from_path"
-    )
-
-    # Ensure the output folder exists
-    os.makedirs(output_folder, exist_ok=True)
-
-    # Convert PDF to a list of PIL Image objects
-    images = convert_from_path(pdf_path, dpi=dpi)
-
-    saved_paths = []
-    for i, image in enumerate(images):
-        # Construct the output file name
-        image_file = os.path.join(output_folder, f"page_{i + 1}.{fmt}")
-        image.save(image_file, fmt.upper())
-        saved_paths.append(image_file)
-
-    return saved_paths