chatterer 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

chatterer/tools/webpage_to_markdown/utils.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 
 import os.path
 import re
-from base64 import b64encode
-from io import BytesIO
 from pathlib import Path
-from traceback import print_exc
 from typing import (
     ClassVar,
     Literal,
@@ -24,14 +21,11 @@ from urllib.parse import urljoin, urlparse
 
 import mistune
 import playwright.sync_api
-import requests
-from aiohttp import ClientSession
-from PIL.Image import Resampling
-from PIL.Image import open as image_open
 from pydantic import BaseModel, Field
 
+from ...utils.image import Base64Image, ImageProcessingConfig
+
 
-# Define a Pydantic model for the selected line ranges returned by the LLM.
 class SelectedLineRanges(BaseModel):
     line_ranges: list[str] = Field(description="List of inclusive line ranges, e.g., ['1-3', '5-5', '7-10']")
 
@@ -68,33 +62,6 @@ def get_default_playwright_launch_options() -> PlaywrightLaunchOptions:
     return {"headless": True}
 
 
-class ImageProcessingConfig(TypedDict):
-    """
-    이미지 필터링/변환 시 사용할 설정.
-      - formats: (Sequence[str]) 허용할 이미지 포맷(소문자, 예: ["jpeg", "png", "webp"]).
-      - max_size_mb: (float) 이미지 용량 상한(MB). 초과 시 제외.
-      - min_largest_side: (int) 가로나 세로 중 가장 큰 변의 최소 크기. 미만 시 제외.
-      - resize_if_min_side_exceeds: (int) 가로나 세로 중 작은 변이 이 값 이상이면 리스케일.
-      - resize_target_for_min_side: (int) 리스케일시, '가장 작은 변'을 이 값으로 줄임(비율 유지는 Lanczos).
-    """
-
-    formats: Sequence[str]
-    max_size_mb: NotRequired[float]
-    min_largest_side: NotRequired[int]
-    resize_if_min_side_exceeds: NotRequired[int]
-    resize_target_for_min_side: NotRequired[int]
-
-
-def get_default_image_processing_config() -> ImageProcessingConfig:
-    return {
-        "max_size_mb": 5,
-        "min_largest_side": 200,
-        "resize_if_min_side_exceeds": 2000,
-        "resize_target_for_min_side": 1000,
-        "formats": ["png", "jpg", "jpeg", "gif", "bmp", "webp"],
-    }
-
-
 class _TrackingInlineState(mistune.InlineState):
     meta_offset: int = 0  # Where in the original text does self.src start?
 
@@ -261,15 +228,6 @@ def _extract_text(tokens: list[dict[str, object]]) -> str:
     return "".join(parts)
 
 
-def _is_url(path: str) -> bool:
-    """
-    path가 절대 URL 형태인지 여부를 bool로 반환
-    (scheme과 netloc이 모두 존재하면 URL로 간주)
-    """
-    parsed = urlparse(path)
-    return bool(parsed.scheme and parsed.netloc)
-
-
 def _to_absolute_path(path: str, referer: str) -> str:
     """
     path     : 변환할 경로(상대/절대 경로 혹은 URL일 수도 있음)
@@ -308,88 +266,16 @@ def _to_absolute_path(path: str, referer: str) -> str:
 # =======================
 
 
-def _get_image_bytes(image_url: str, headers: dict[str, str]) -> Optional[bytes]:
-    try:
-        with requests.Session() as session:
-            response = session.get(image_url, headers={k: str(v) for k, v in headers.items()})
-            if not response.ok:
-                return
-            return bytes(response.content or b"")
-    except Exception:
-        return
-
-
-async def _aget_image_bytes(image_url: str, headers: dict[str, str]) -> Optional[bytes]:
-    try:
-        async with ClientSession() as session:
-            async with session.get(image_url, headers={k: str(v) for k, v in headers.items()}) as response:
-                if not response.ok:
-                    return
-                return await response.read()
-    except Exception:
-        return
-
-
-# =======================
-
-
-def _fetch_remote_image(url: str, headers: dict[str, str], config: ImageProcessingConfig) -> Optional[str]:
-    image_bytes = _get_image_bytes(image_url=url.strip(), headers=headers)
-    if not image_bytes:
-        return None
-    return _convert_image_into_base64(image_bytes, config)
-
-
-async def _afetch_remote_image(url: str, headers: dict[str, str], config: ImageProcessingConfig) -> Optional[str]:
-    image_bytes = await _aget_image_bytes(image_url=url.strip(), headers=headers)
-    if not image_bytes:
-        return None
-    return _convert_image_into_base64(image_bytes, config)
-
-
-# =======================
-
-
-def _process_markdown_image(
-    markdown_link: MarkdownLink, headers: dict[str, str], config: ImageProcessingConfig
-) -> Optional[str]:
-    """마크다운 이미지 패턴에 매칭된 하나의 이미지를 처리해 Base64 URL을 반환(동기)."""
-    if markdown_link.type != "image":
-        return
-    url: str = markdown_link.url
-    if url.startswith("data:image/"):
-        return url
-    elif _is_url(url):
-        return _fetch_remote_image(url, headers, config)
-    return _process_local_image(Path(url), config)
-
-
-async def _aprocess_markdown_image(
-    markdown_link: MarkdownLink, headers: dict[str, str], config: ImageProcessingConfig
-) -> Optional[str]:
-    """마크다운 이미지 패턴에 매칭된 하나의 이미지를 처리해 Base64 URL을 반환(비동기)."""
-    if markdown_link.type != "image":
-        return
-    url: str = markdown_link.url
-    if url.startswith("data:image/"):
-        return url
-    elif _is_url(url):
-        return await _afetch_remote_image(url, headers, config)
-    return _process_local_image(Path(url), config)
-
-
-# =======================
-
-
 def get_image_url_and_markdown_links(
     markdown_text: str, headers: dict[str, str], config: ImageProcessingConfig
-) -> dict[Optional[str], list[MarkdownLink]]:
-    image_matches: dict[Optional[str], list[MarkdownLink]] = {}
+) -> dict[Optional[Base64Image], list[MarkdownLink]]:
+    image_matches: dict[Optional[Base64Image], list[MarkdownLink]] = {}
     for markdown_link in MarkdownLink.from_markdown(markdown_text=markdown_text, referer_url=headers.get("Referer")):
         if markdown_link.type == "link":
             image_matches.setdefault(None, []).append(markdown_link)
             continue
-        image_data = _process_markdown_image(markdown_link, headers, config)
+
+        image_data = Base64Image.from_url_or_path(markdown_link.url, headers=headers, config=config)
         if not image_data:
             continue
         image_matches.setdefault(image_data, []).append(markdown_link)
@@ -398,134 +284,21 @@ def get_image_url_and_markdown_links(
 
 async def aget_image_url_and_markdown_links(
     markdown_text: str, headers: dict[str, str], config: ImageProcessingConfig
-) -> dict[Optional[str], list[MarkdownLink]]:
-    image_matches: dict[Optional[str], list[MarkdownLink]] = {}
+) -> dict[Optional[Base64Image], list[MarkdownLink]]:
+    image_matches: dict[Optional[Base64Image], list[MarkdownLink]] = {}
     for markdown_link in MarkdownLink.from_markdown(markdown_text=markdown_text, referer_url=headers.get("Referer")):
         if markdown_link.type == "link":
             image_matches.setdefault(None, []).append(markdown_link)
             continue
-        image_data = await _aprocess_markdown_image(markdown_link, headers, config)
+        image_data = await Base64Image.from_url_or_path(
+            markdown_link.url, headers=headers, config=config, return_coro=True
+        )
         if not image_data:
             continue
         image_matches.setdefault(image_data, []).append(markdown_link)
     return image_matches
 
 
-# =======================
-
-
-def _simple_base64_encode(image_data: bytes) -> Optional[str]:
-    """
-    Retrieve an image URL and return a base64-encoded data URL.
-    """
-    image_type = _detect_image_type(image_data)
-    if not image_type:
-        return
-    encoded_data = b64encode(image_data).decode("utf-8")
-    return f"data:image/{image_type};base64,{encoded_data}"
-
-
-def _convert_image_into_base64(image_data: bytes, config: Optional[ImageProcessingConfig]) -> Optional[str]:
-    """
-    Retrieve an image in bytes and return a base64-encoded data URL,
-    applying dynamic rules from 'config'.
-    """
-    if not config:
-        # config 없으면 그냥 기존 헤더만 보고 돌려주는 간단 로직
-        return _simple_base64_encode(image_data)
-
-    # 1) 용량 검사
-    max_size_mb = config.get("max_size_mb", float("inf"))
-    image_size_mb = len(image_data) / (1024 * 1024)
-    if image_size_mb > max_size_mb:
-        print(f"Image too large: {image_size_mb:.2f} MB > {max_size_mb} MB")
-        return None
-
-    # 2) Pillow로 이미지 열기
-    try:
-        with image_open(BytesIO(image_data)) as im:
-            w, h = im.size
-            # 가장 큰 변
-            largest_side = max(w, h)
-            # 가장 작은 변
-            smallest_side = min(w, h)
-
-            # min_largest_side 기준
-            min_largest_side = config.get("min_largest_side", 1)
-            if largest_side < min_largest_side:
-                print(f"Image too small: {largest_side} < {min_largest_side}")
-                return None
-
-            # resize 로직
-            resize_if_min_side_exceeds = config.get("resize_if_min_side_exceeds", float("inf"))
-            if smallest_side >= resize_if_min_side_exceeds:
-                # resize_target_for_min_side 로 축소
-                resize_target = config.get("resize_target_for_min_side", 1000)
-                ratio = resize_target / float(smallest_side)
-                new_w = int(w * ratio)
-                new_h = int(h * ratio)
-                im = im.resize((new_w, new_h), Resampling.LANCZOS)
-
-            # 포맷 제한
-            # PIL이 인식한 포맷이 대문자(JPEG)일 수 있으므로 소문자로
-            pil_format = (im.format or "").lower()
-            allowed_formats = config.get("formats", [])
-            if pil_format not in allowed_formats:
-                print(f"Invalid format: {pil_format} not in {allowed_formats}")
-                return None
-
-            # JPG -> JPEG 로 포맷명 정리
-            if pil_format == "jpg":
-                pil_format = "jpeg"
-
-            # 다시 bytes 로 저장
-            output_buffer = BytesIO()
-            im.save(output_buffer, format=pil_format.upper())  # PIL에 맞춰서 대문자로
-            output_buffer.seek(0)
-            final_bytes = output_buffer.read()
-
-    except Exception:
-        print_exc()
-        return None
-
-    # 최종 base64 인코딩
-    encoded_data = b64encode(final_bytes).decode("utf-8")
-    return f"data:image/{pil_format};base64,{encoded_data}"
-
-
-def _detect_image_type(image_data: bytes) -> Optional[str]:
-    """
-    Detect the image format based on the image binary signature (header).
-    Only JPEG, PNG, GIF, WEBP, and BMP are handled as examples.
-    If the format is not recognized, return None.
-    """
-    # JPEG: 시작 바이트가 FF D8 FF
-    if image_data.startswith(b"\xff\xd8\xff"):
-        return "jpeg"
-    # PNG: 시작 바이트가 89 50 4E 47 0D 0A 1A 0A
-    elif image_data.startswith(b"\x89PNG\r\n\x1a\n"):
-        return "png"
-    # GIF: 시작 바이트가 GIF87a 또는 GIF89a
-    elif image_data.startswith(b"GIF87a") or image_data.startswith(b"GIF89a"):
-        return "gif"
-    # WEBP: 시작 바이트가 RIFF....WEBP
-    elif image_data.startswith(b"RIFF") and image_data[8:12] == b"WEBP":
-        return "webp"
-    # BMP: 시작 바이트가 BM
-    elif image_data.startswith(b"BM"):
-        return "bmp"
-
-
-def _process_local_image(path: Path, config: ImageProcessingConfig) -> Optional[str]:
-    """로컬 파일이 존재하고 유효한 이미지 포맷이면 Base64 데이터 URL을 반환, 아니면 None."""
-    if not path.is_file():
-        return None
-    lowered_suffix = path.suffix.lower()
-    if not lowered_suffix or (lowered_suffix_without_dot := lowered_suffix[1:]) not in config["formats"]:
-        return None
-    return f"data:image/{lowered_suffix_without_dot};base64,{path.read_bytes().hex()}"
-
-
 def replace_images(
     markdown_text: str, image_description_and_references: ImageDescriptionAndReferences, description_format: str
 ) -> str:

chatterer/utils/image.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import re
+from base64 import b64encode
+from io import BytesIO
+from pathlib import Path
+from traceback import print_exc
+from typing import (
+    Awaitable,
+    ClassVar,
+    Literal,
+    NotRequired,
+    Optional,
+    Self,
+    Sequence,
+    TypeAlias,
+    TypedDict,
+    TypeGuard,
+    cast,
+    get_args,
+    overload,
+)
+from urllib.parse import urlparse
+
+import requests
+from aiohttp import ClientSession
+from PIL.Image import Resampling
+from PIL.Image import open as image_open
+from pydantic import BaseModel
+
+ImageType: TypeAlias = Literal["jpeg", "jpg", "png", "gif", "webp", "bmp"]
+
+
+class ImageProcessingConfig(TypedDict):
+    """
+    이미지 필터링/변환 시 사용할 설정.
+      - formats: (Sequence[str]) 허용할 이미지 포맷(소문자, 예: ["jpeg", "png", "webp"]).
+      - max_size_mb: (float) 이미지 용량 상한(MB). 초과 시 제외.
+      - min_largest_side: (int) 가로나 세로 중 가장 큰 변의 최소 크기. 미만 시 제외.
+      - resize_if_min_side_exceeds: (int) 가로나 세로 중 작은 변이 이 값 이상이면 리스케일.
+      - resize_target_for_min_side: (int) 리스케일시, '가장 작은 변'을 이 값으로 줄임(비율 유지는 Lanczos).
+    """
+
+    formats: Sequence[ImageType]
+    max_size_mb: NotRequired[float]
+    min_largest_side: NotRequired[int]
+    resize_if_min_side_exceeds: NotRequired[int]
+    resize_target_for_min_side: NotRequired[int]
+
+
+def get_default_image_processing_config() -> ImageProcessingConfig:
+    return {
+        "max_size_mb": 5,
+        "min_largest_side": 200,
+        "resize_if_min_side_exceeds": 2000,
+        "resize_target_for_min_side": 1000,
+        "formats": ["png", "jpeg", "gif", "bmp", "webp"],
+    }
+
+
+class Base64Image(BaseModel):
+    ext: ImageType
+    data: str
+
+    IMAGE_TYPES: ClassVar[tuple[str, ...]] = tuple(map(str, get_args(ImageType)))
+    IMAGE_PATTERN: ClassVar[re.Pattern[str]] = re.compile(
+        rf"data:image/({'|'.join(IMAGE_TYPES)});base64,[A-Za-z0-9+/]+={0, 2}$"
+    )
+
+    def __hash__(self) -> int:
+        return hash((self.ext, self.data))
+
+    def model_post_init(self, __context: object) -> None:
+        if self.ext == "jpg":
+            self.ext = "jpeg"
+
+    @classmethod
+    def from_string(cls, data: str) -> Optional[Self]:
+        match = cls.IMAGE_PATTERN.fullmatch(data)
+        if not match:
+            return None
+        return cls(ext=cast(ImageType, match.group(1)), data=match.group(2))
+
+    @classmethod
+    def from_bytes(cls, data: bytes, ext: ImageType) -> Self:
+        return cls(ext=ext, data=b64encode(data).decode("utf-8"))
+
+    @overload
+    @classmethod
+    def from_url_or_path(
+        cls,
+        url_or_path: str,
+        *,
+        headers: dict[str, str] = ...,
+        config: ImageProcessingConfig = ...,
+        return_coro: Literal[True],
+    ) -> Awaitable[Optional[Self]]: ...
+
+    @overload
+    @classmethod
+    def from_url_or_path(
+        cls,
+        url_or_path: str,
+        *,
+        headers: dict[str, str] = ...,
+        config: ImageProcessingConfig = ...,
+        return_coro: Literal[False] = False,
+    ) -> Optional[Self]: ...
+
+    @classmethod
+    def from_url_or_path(
+        cls,
+        url_or_path: str,
+        *,
+        headers: dict[str, str] = {},
+        config: ImageProcessingConfig = get_default_image_processing_config(),
+        return_coro: bool = False,
+    ) -> Optional[Self] | Awaitable[Optional[Self]]:
+        """Return a Base64Image instance from a URL or local file path."""
+        if maybe_base64 := cls.from_string(url_or_path):
+            return maybe_base64
+        elif _is_remote_url(url_or_path):
+            if return_coro:
+                return cls._afetch_remote_image(url_or_path, headers, config)
+            return cls._fetch_remote_image(url_or_path, headers, config)
+        return cls._process_local_image(Path(url_or_path), config)
+
+    @property
+    def data_uri(self) -> str:
+        return f"data:image/{self.ext.replace('jpg', 'jpeg')};base64,{self.data}"
+
+    @property
+    def data_uri_content(self) -> dict[Literal["type", "image_url"], Literal["image_url"] | dict[Literal["url"], str]]:
+        return {"type": "image_url", "image_url": {"url": self.data_uri}}
+
+    @staticmethod
+    def _verify_ext(ext: str, allowed_types: Sequence[ImageType]) -> TypeGuard[ImageType]:
+        return ext in allowed_types
+
+    @classmethod
+    def _fetch_remote_image(cls, url: str, headers: dict[str, str], config: ImageProcessingConfig) -> Optional[Self]:
+        image_bytes = _get_image_bytes(image_url=url.strip(), headers=headers)
+        if not image_bytes:
+            return None
+        return cls._convert_image_into_base64(image_bytes, config)
+
+    @classmethod
+    async def _afetch_remote_image(
+        cls, url: str, headers: dict[str, str], config: ImageProcessingConfig
+    ) -> Optional[Self]:
+        image_bytes = await _aget_image_bytes(image_url=url.strip(), headers=headers)
+        if not image_bytes:
+            return None
+        return cls._convert_image_into_base64(image_bytes, config)
+
+    @classmethod
+    def _convert_image_into_base64(cls, image_data: bytes, config: Optional[ImageProcessingConfig]) -> Optional[Self]:
+        """
+        Retrieve an image in bytes and return a base64-encoded data URL,
+        applying dynamic rules from 'config'.
+        """
+        if not config:
+            # config 없으면 그냥 기존 헤더만 보고 돌려주는 간단 로직
+            return cls._simple_base64_encode(image_data)
+
+        # 1) 용량 검사
+        max_size_mb = config.get("max_size_mb", float("inf"))
+        image_size_mb = len(image_data) / (1024 * 1024)
+        if image_size_mb > max_size_mb:
+            print(f"Image too large: {image_size_mb:.2f} MB > {max_size_mb} MB")
+            return None
+
+        # 2) Pillow로 이미지 열기
+        try:
+            with image_open(BytesIO(image_data)) as im:
+                w, h = im.size
+                # 가장 큰 변
+                largest_side = max(w, h)
+                # 가장 작은 변
+                smallest_side = min(w, h)
+
+                # min_largest_side 기준
+                min_largest_side = config.get("min_largest_side", 1)
+                if largest_side < min_largest_side:
+                    print(f"Image too small: {largest_side} < {min_largest_side}")
+                    return None
+
+                # resize 로직
+                resize_if_min_side_exceeds = config.get("resize_if_min_side_exceeds", float("inf"))
+                if smallest_side >= resize_if_min_side_exceeds:
+                    # resize_target_for_min_side 로 축소
+                    resize_target = config.get("resize_target_for_min_side", 1000)
+                    ratio = resize_target / float(smallest_side)
+                    new_w = int(w * ratio)
+                    new_h = int(h * ratio)
+                    im = im.resize((new_w, new_h), Resampling.LANCZOS)
+
+                # 포맷 제한
+                # PIL이 인식한 포맷이 대문자(JPEG)일 수 있으므로 소문자로
+                pil_format: str = (im.format or "").lower()
+                allowed_formats: Sequence[ImageType] = config.get("formats", [])
+                if not cls._verify_ext(pil_format, allowed_formats):
+                    print(f"Invalid format: {pil_format} not in {allowed_formats}")
+                    return None
+
+                # 다시 bytes 로 저장
+                output_buffer = BytesIO()
+                im.save(output_buffer, format=pil_format.upper())  # PIL에 맞춰서 대문자로
+                output_buffer.seek(0)
+                final_bytes = output_buffer.read()
+
+        except Exception:
+            print_exc()
+            return None
+
+        # 최종 base64 인코딩
+        encoded_data = b64encode(final_bytes).decode("utf-8")
+        return cls(ext=pil_format, data=encoded_data)
+
+    @classmethod
+    def _simple_base64_encode(cls, image_data: bytes) -> Optional[Self]:
+        """
+        Retrieve an image URL and return a base64-encoded data URL.
+        """
+        ext = _detect_image_type(image_data)
+        if not ext:
+            return
+        return cls(ext=ext, data=b64encode(image_data).decode("utf-8"))
+
+    @classmethod
+    def _process_local_image(cls, path: Path, config: ImageProcessingConfig) -> Optional[Self]:
+        """로컬 파일이 존재하고 유효한 이미지 포맷이면 Base64 데이터 URL을 반환, 아니면 None."""
+        if not path.is_file():
+            return None
+        ext = path.suffix.lower().removeprefix(".")
+        if not cls._verify_ext(ext, config["formats"]):
+            return None
+        return cls(ext=ext, data=b64encode(path.read_bytes()).decode("ascii"))
+
+
+def _is_remote_url(path: str) -> bool:
+    parsed = urlparse(path)
+    return bool(parsed.scheme and parsed.netloc)
+
+
+def _detect_image_type(image_data: bytes) -> Optional[ImageType]:
+    """
+    Detect the image format based on the image binary signature (header).
+    Only JPEG, PNG, GIF, WEBP, and BMP are handled as examples.
+    If the format is not recognized, return None.
+    """
+    # JPEG: 시작 바이트가 FF D8 FF
+    if image_data.startswith(b"\xff\xd8\xff"):
+        return "jpeg"
+    # PNG: 시작 바이트가 89 50 4E 47 0D 0A 1A 0A
+    elif image_data.startswith(b"\x89PNG\r\n\x1a\n"):
+        return "png"
+    # GIF: 시작 바이트가 GIF87a 또는 GIF89a
+    elif image_data.startswith(b"GIF87a") or image_data.startswith(b"GIF89a"):
+        return "gif"
+    # WEBP: 시작 바이트가 RIFF....WEBP
+    elif image_data.startswith(b"RIFF") and image_data[8:12] == b"WEBP":
+        return "webp"
+    # BMP: 시작 바이트가 BM
+    elif image_data.startswith(b"BM"):
+        return "bmp"
+
+
+def _get_image_bytes(image_url: str, headers: dict[str, str]) -> Optional[bytes]:
+    try:
+        with requests.Session() as session:
+            response = session.get(image_url, headers={k: str(v) for k, v in headers.items()})
+            if not response.ok:
+                return
+            return bytes(response.content or b"")
+    except Exception:
+        return
+
+
+async def _aget_image_bytes(image_url: str, headers: dict[str, str]) -> Optional[bytes]:
+    try:
+        async with ClientSession() as session:
+            async with session.get(image_url, headers={k: str(v) for k, v in headers.items()}) as response:
+                if not response.ok:
+                    return
+                return await response.read()
+    except Exception:
+        return

{chatterer-0.1.6.dist-info → chatterer-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: chatterer
-Version: 0.1.6
+Version: 0.1.8
 Summary: The highest-level interface for various LLM APIs.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

chatterer-0.1.8.dist-info/RECORD

@@ -0,0 +1,24 @@
+chatterer/__init__.py,sha256=kl8VWiDJIt5IQjaBpQu13n0GrzP3qzaNXyA68B1xHTE,802
+chatterer/language_model.py,sha256=S8x2IbzZBi1mAKSKrGuoB4-gfKBz73RCNXt_H-fiDzc,13826
+chatterer/messages.py,sha256=-NyOIK7wJI1uVD8qaJPeLA0LqirFEsZ1mOYoO1F2wLc,188
+chatterer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chatterer/strategies/__init__.py,sha256=SdOggbmHpw4f7Njwy-T8q64e91OLOUp1k0a0ozZd4qI,221
+chatterer/strategies/atom_of_thoughts.py,sha256=CygOCLu5vLk-fzY9O-iE3qLShfjD7iY40ks9jH4ULBM,40872
+chatterer/strategies/base.py,sha256=b2gMPqodp97OP1dkHfj0UqixjdjVhmTw_V5qJ7i2S6g,427
+chatterer/tools/__init__.py,sha256=yA4RcHIAO33xsmWXQTmtSm9bk1p80yJKSadtMa3X-aY,415
+chatterer/tools/convert_to_text.py,sha256=kBqxCJ0IoiAw2eiPYqep_SPZm-TtYKF7mdACLsWQUuI,15915
+chatterer/tools/citation_chunking/__init__.py,sha256=gG7Fnkkp28UpcWMbfMY_4gqzZSZ8QzlhalHBoeoq7K0,82
+chatterer/tools/citation_chunking/chunks.py,sha256=50Dpa43RaYftlNox8tM1qI8htZ3_AJ9Uyyn02WsmxYk,2173
+chatterer/tools/citation_chunking/citation_chunker.py,sha256=yx5O9pUkowlNcFyyNf7f3sbq7-CV8AXOzFnviDldPR8,4894
+chatterer/tools/citation_chunking/citations.py,sha256=RWVJA38yvlER9PhLDPZnqaRsbQ334W4FDQXBqGpdi08,12593
+chatterer/tools/citation_chunking/prompt.py,sha256=S0Z6v8R23_Vknt3qYyjoDE1_gBsb0fCEx7LIw7BFXmA,7714
+chatterer/tools/citation_chunking/reference.py,sha256=uRKufkU41Zedz6MQUCy-aCk4Rwxg94m4b332zKDpXAs,919
+chatterer/tools/citation_chunking/utils.py,sha256=M4pH2-UIE1VLzQLXDqjEe4L3Xcy0e0KhAP3I2U2BNms,6348
+chatterer/tools/webpage_to_markdown/__init__.py,sha256=bHH4qfnXyw8Zz-yBPLaTezF1sh9njvNBJmhBVtcpjsA,123
+chatterer/tools/webpage_to_markdown/playwright_bot.py,sha256=yP0KixYZNQ4Kn_ZCFDI3mVyBD_DpUGfqgklpaGJUTCU,27496
+chatterer/tools/webpage_to_markdown/utils.py,sha256=ZLUU94imYciEdynD2K7Dmcsbt8BVQTaOP56Ba6DAFvk,12593
+chatterer/utils/image.py,sha256=F3_D1677UDFlgp-UQBS_ChkNODzf_VOfjYNSUi02MaI,10852
+chatterer-0.1.8.dist-info/METADATA,sha256=01CGNp0oae5VdHM5gzqPKYFtlSqufE0h5XFMdn2E_6c,4234
+chatterer-0.1.8.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+chatterer-0.1.8.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
+chatterer-0.1.8.dist-info/RECORD,,

{chatterer-0.1.6.dist-info → chatterer-0.1.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (77.0.3)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

chatterer-0.1.6.dist-info/RECORD

@@ -1,15 +0,0 @@
-chatterer/__init__.py,sha256=9mpj_kaqaGPvaAng2Ol1fzWftYvIs4y97v9umXWPWJg,572
-chatterer/language_model.py,sha256=dHHjXPje9FjRpEA0cV1G9LJwkiOSfMyVMOTXvrTo69A,12275
-chatterer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chatterer/strategies/__init__.py,sha256=SdOggbmHpw4f7Njwy-T8q64e91OLOUp1k0a0ozZd4qI,221
-chatterer/strategies/atom_of_thoughts.py,sha256=S_j4R26Drr8qJjAA9HYtWRF1_F4_ldo11_A2Z1ObYOI,40936
-chatterer/strategies/base.py,sha256=b2gMPqodp97OP1dkHfj0UqixjdjVhmTw_V5qJ7i2S6g,427
-chatterer/tools/__init__.py,sha256=YJc0xaDGwcdHvVlz-xFRjzrek2Q8icxc4Xsq2nOQXQA,341
-chatterer/tools/convert_to_text.py,sha256=5bOlo9hkUJtJhrB5hmEl4VM-_3Qoh3c2CxUrGmVOoQ4,16188
-chatterer/tools/webpage_to_markdown/__init__.py,sha256=bHH4qfnXyw8Zz-yBPLaTezF1sh9njvNBJmhBVtcpjsA,123
-chatterer/tools/webpage_to_markdown/playwright_bot.py,sha256=9k5e4jy6QrekEg8J7ZuJ_E_akDHyZ6yQI-AhTaclEfc,26687
-chatterer/tools/webpage_to_markdown/utils.py,sha256=0_LnrU7WLM0TbEXcNSND9xEDW4geS0OTCpQszHq68zE,21282
-chatterer-0.1.6.dist-info/METADATA,sha256=O-5dA1okHEZJanGLLKwDoZR04aQDSj7_1MNjykVbcws,4234
-chatterer-0.1.6.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-chatterer-0.1.6.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
-chatterer-0.1.6.dist-info/RECORD,,