chatterer 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

chatterer-0.1.16.dist-info/RECORD

@@ -0,0 +1,33 @@
+chatterer/__init__.py,sha256=1z3ocUMqgbqQ3eD4wq5Jq-JPt-VuWwdWT_U8r38Hodo,2267
+chatterer/interactive.py,sha256=-eWDeoGgdEUh8GTVCddhrueoDN5YwIeB_SPHBaXlltc,32863
+chatterer/language_model.py,sha256=4aJrBHpDbFrGfcGOmglSy1IYFOhyiNGen20-BysqQTM,20659
+chatterer/messages.py,sha256=j_bjOVE2FbBaYYpykmJrQL-IH_BWyiZ1VAUCj_wSA2U,479
+chatterer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chatterer/common_types/__init__.py,sha256=jfS6m5UANSvGjzQ_nzYDpryn5uZqNb06-4xCsQ2C_lw,376
+chatterer/common_types/io.py,sha256=fetiyi1suZ3NF2mj5k5KDLJLGKS1n4J-5UmH7JN36g8,817
+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=m3PRK9H5vOhk-2gG9W2eg8CYBlEn-K9-eaulOu91bgo,1474
+chatterer/tools/caption_markdown_images.py,sha256=r4QajHYuL4mdyYQXP1vQcNmqKN8lxBf5y0VKELXILOI,15392
+chatterer/tools/convert_pdf_to_markdown.py,sha256=8VEnZiaZSDq5k5BGaJEaSaJpJrAxSeL-gc7s38Vf9Fg,14990
+chatterer/tools/convert_to_text.py,sha256=IWtSHBh8-bvEZekk9Vli8yK4Ufa_VezN9mpfKCUWvys,15443
+chatterer/tools/upstage_document_parser.py,sha256=Bn6dGwgCsCOvhA5GfTWcfJ9unKqyuXNMMwoqZLwYLYU,33103
+chatterer/tools/webpage_to_markdown.py,sha256=ADH4sqM6iquJR7HU6umMQ5qO7EvcbNutuchXDpAcxAo,31961
+chatterer/tools/youtube.py,sha256=Hl2MMXJwwZ-i6_YAq0zh0rN4LHpYOb1Rt88P1gMjlLE,6081
+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/utils/__init__.py,sha256=2v-lB2dqHgBlGcyaKKHc_hcyeH_AVoOddpr0STF7YAw,341
+chatterer/utils/base64_image.py,sha256=m_qAT3ERBiq8D-H4H9Z7rLfL31_BiPmV_m4uQ5XRLs0,11124
+chatterer/utils/bytesio.py,sha256=3MC2atOOFKo5YxuReo_y_t8Wem9p2Y1ahC5M2lGclwI,2618
+chatterer/utils/code_agent.py,sha256=A0IIgUAvW3lWMdJa8OZNKqmwdd5uuSvco-TxAN5-cek,10468
+chatterer/utils/imghdr.py,sha256=6JhJMXD4MZ0dQolT2VM87YrRYm3hPf3RTEWnP4lYRVc,3842
+chatterer-0.1.16.dist-info/METADATA,sha256=6efEZcoXWxrR82TuAtkXSQEOdqxmzy4Qlbp_Rj8J2vE,11858
+chatterer-0.1.16.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+chatterer-0.1.16.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
+chatterer-0.1.16.dist-info/RECORD,,

{chatterer-0.1.14.dist-info → chatterer-0.1.16.dist-info}/WHEEL

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

chatterer/utils/cli.py

@@ -1,476 +0,0 @@
-import argparse
-import io
-import typing
-import warnings
-from dataclasses import dataclass, field, fields
-from typing import (
-    IO,
-    Callable,
-    Dict,
-    Generic,
-    Iterable,
-    List,
-    Literal,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    TypeVar,
-    Union,
-)
-
-# --- Type Definitions ---
-SUPPRESS_LITERAL_TYPE = Literal["==SUPPRESS=="]
-SUPPRESS: SUPPRESS_LITERAL_TYPE = "==SUPPRESS=="
-ACTION_TYPES_THAT_DONT_SUPPORT_TYPE_KWARG = (
-    "store_const",
-    "store_true",
-    "store_false",
-    "append_const",
-    "count",
-    "help",
-    "version",
-)
-Action = Optional[
-    Literal[
-        "store",
-        "store_const",
-        "store_true",
-        "store_false",
-        "append",
-        "append_const",
-        "count",
-        "help",
-        "version",
-        "extend",
-    ]
-]
-T = TypeVar("T")
-
-
-@dataclass
-class ArgumentSpec(Generic[T]):
-    """Represents the specification for a command-line argument."""
-
-    name_or_flags: List[str]
-    action: Action = None
-    nargs: Optional[Union[int, Literal["*", "+", "?"]]] = None
-    const: Optional[object] = None
-    default: Optional[Union[T, SUPPRESS_LITERAL_TYPE]] = None
-    choices: Optional[Sequence[T]] = None
-    required: bool = False
-    help: str = ""
-    metavar: Optional[str] = None
-    version: Optional[str] = None
-    type: Optional[Union[Callable[[str], T], argparse.FileType]] = None
-    value: Optional[T] = field(init=False, default=None)  # Parsed value stored here
-
-    @property
-    def value_not_none(self) -> T:
-        """Returns the value, raising an error if it's None."""
-        if self.value is None:
-            raise ValueError(f"Value for {self.name_or_flags} is None.")
-        return self.value
-
-    def get_add_argument_kwargs(self) -> Dict[str, object]:
-        """Prepares keyword arguments for argparse.ArgumentParser.add_argument."""
-        kwargs: Dict[str, object] = {}
-        argparse_fields: set[str] = {f.name for f in fields(self) if f.name not in ("name_or_flags", "value")}
-        for field_name in argparse_fields:
-            attr_value = getattr(self, field_name)
-            if field_name == "default":
-                if attr_value is None:
-                    pass  # Keep default=None if explicitly set or inferred
-                elif attr_value in get_args(SUPPRESS_LITERAL_TYPE):
-                    kwargs[field_name] = argparse.SUPPRESS
-                else:
-                    kwargs[field_name] = attr_value
-            elif attr_value is not None:
-                if field_name == "type" and self.action in ACTION_TYPES_THAT_DONT_SUPPORT_TYPE_KWARG:
-                    continue
-                kwargs[field_name] = attr_value
-        return kwargs
-
-
-class ArgumentSpecType(NamedTuple):
-    T: object  # The T in ArgumentSpec[T]
-    element_type: typing.Optional[typing.Type[object]]  # The E in ArgumentSpec[List[E]] or ArgumentSpec[Tuple[E]]
-
-    @classmethod
-    def from_hint(cls, hints: Dict[str, object], attr_name: str):
-        if (
-            (hint := hints.get(attr_name))
-            and (hint_origin := get_origin(hint))
-            and (hint_args := get_args(hint))
-            and isinstance(hint_origin, type)
-            and issubclass(hint_origin, ArgumentSpec)
-        ):
-            T: object = hint_args[0]  # Extract T
-            element_type: typing.Optional[object] = None
-            if isinstance(outer_origin := get_origin(T), type):
-                if issubclass(outer_origin, list) and (args := get_args(T)):
-                    element_type = args[0]  # Extract E
-                elif issubclass(outer_origin, tuple) and (args := get_args(T)):
-                    element_type = args  # Extract E
-                else:
-                    element_type = None  # The E in ArgumentSpec[List[E]] or Tuple[E, ...]
-                if not isinstance(element_type, type):
-                    element_type = None
-            return cls(T=T, element_type=element_type)
-
-    @property
-    def choices(self) -> typing.Optional[Tuple[object, ...]]:
-        # ArgumentSpec[Literal["A", "B"]] or ArgumentSpec[List[Literal["A", "B"]]]
-        T_origin = get_origin(self.T)
-        if (
-            isinstance(T_origin, type)
-            and (issubclass(T_origin, (list, tuple)))
-            and (args := get_args(self.T))
-            and (get_origin(arg := args[0]) is typing.Literal)
-            and (literals := get_args(arg))
-        ):
-            return literals
-        elif T_origin is typing.Literal and (args := get_args(self.T)):
-            return args
-
-    @property
-    def type(self) -> typing.Optional[typing.Type[object]]:
-        if self.element_type is not None:
-            return self.element_type  # If it's List[E] or Sequence[E], use E as type
-        elif self.T and isinstance(self.T, type):
-            return self.T  # Use T as type
-
-    @property
-    def should_return_as_list(self) -> bool:
-        """Determines if the argument should be returned as a list."""
-        T_origin = get_origin(self.T)
-        if isinstance(T_origin, type):
-            if issubclass(T_origin, list):
-                return True
-        return False
-
-    @property
-    def should_return_as_tuple(self) -> bool:
-        """Determines if the argument should be returned as a tuple."""
-        T_origin = get_origin(self.T)
-        if isinstance(T_origin, type):
-            if issubclass(T_origin, tuple):
-                return True
-        return False
-
-    @property
-    def tuple_nargs(self) -> Optional[int]:
-        if self.should_return_as_tuple and (args := get_args(self.T)) and Ellipsis not in args:
-            return len(args)
-
-
-class BaseArguments:
-    """Base class for defining arguments declaratively using ArgumentSpec."""
-
-    __argspec__: Dict[str, ArgumentSpec[object]]
-    __argspectype__: Dict[str, ArgumentSpecType]
-
-    def __init_subclass__(cls, **kwargs: object) -> None:
-        """
-        Processes ArgumentSpec definitions in subclasses upon class creation.
-        Automatically infers 'type' and 'choices' from type hints if possible.
-        """
-        super().__init_subclass__(**kwargs)
-        cls.__argspec__ = {}
-        cls.__argspectype__ = {}
-        for current_cls in reversed(cls.__mro__):
-            if current_cls is object or current_cls is BaseArguments:
-                continue
-            current_vars = vars(current_cls)
-            try:
-                hints: Dict[str, object] = typing.get_type_hints(current_cls, globalns=dict(current_vars))
-                for attr_name, attr_value in current_vars.items():
-                    if isinstance(attr_value, ArgumentSpec):
-                        attr_value = typing.cast(ArgumentSpec[object], attr_value)
-                        if arguments_spec_type := ArgumentSpecType.from_hint(hints=hints, attr_name=attr_name):
-                            cls.__argspectype__[attr_name] = arguments_spec_type
-                            if attr_value.choices is None and (literals := arguments_spec_type.choices):
-                                attr_value.choices = literals
-                            if attr_value.type is None and (type := arguments_spec_type.type):
-                                attr_value.type = type
-                            if tuple_nargs := arguments_spec_type.tuple_nargs:
-                                attr_value.nargs = tuple_nargs
-                        cls.__argspec__[attr_name] = attr_value
-            except Exception as e:
-                warnings.warn(f"Could not fully analyze type hints for {current_cls.__name__}: {e}", stacklevel=2)
-                for attr_name, attr_value in current_vars.items():
-                    if isinstance(attr_value, ArgumentSpec) and attr_name not in cls.__argspec__:
-                        cls.__argspec__[attr_name] = attr_value
-
-    @classmethod
-    def iter_specs(cls) -> Iterable[Tuple[str, ArgumentSpec[object]]]:
-        """Iterates over the registered (attribute_name, ArgumentSpec) pairs."""
-        yield from cls.__argspec__.items()
-
-    @classmethod
-    def get_parser(cls) -> argparse.ArgumentParser:
-        """Creates and configures an ArgumentParser based on the defined ArgumentSpecs."""
-        arg_parser = argparse.ArgumentParser(
-            description=cls.__doc__,  # Use class docstring as description
-            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-            add_help=False,  # Add custom help argument later
-        )
-        # Add standard help argument
-        arg_parser.add_argument(
-            "-h", "--help", action="help", default=argparse.SUPPRESS, help="Show this help message and exit."
-        )
-        # Add arguments to the parser based on registered ArgumentSpecs
-        for key, spec in cls.iter_specs():
-            kwargs = spec.get_add_argument_kwargs()
-            # Determine if it's a positional or optional argument
-            is_positional: bool = not any(name.startswith("-") for name in spec.name_or_flags)
-            if is_positional:
-                # For positional args: remove 'required' (implicit), let argparse derive 'dest'
-                kwargs.pop("required", None)
-                try:
-                    arg_parser.add_argument(*spec.name_or_flags, **kwargs)  # pyright: ignore[reportArgumentType]
-                except Exception as e:
-                    # Provide informative error message
-                    raise ValueError(
-                        f"Error adding positional argument '{key}' with spec {spec.name_or_flags} and kwargs {kwargs}: {e}"
-                    ) from e
-            else:  # Optional argument
-                try:
-                    # For optional args: explicitly set 'dest' to the attribute name ('key')
-                    arg_parser.add_argument(*spec.name_or_flags, dest=key, **kwargs)  # pyright: ignore[reportArgumentType]
-                except Exception as e:
-                    # Provide informative error message
-                    raise ValueError(
-                        f"Error adding optional argument '{key}' with spec {spec.name_or_flags} and kwargs {kwargs}: {e}"
-                    ) from e
-        return arg_parser
-
-    @classmethod
-    def load(cls, args: Optional[Sequence[str]] = None) -> None:
-        """
-        Parses command-line arguments and assigns the values to the corresponding ArgumentSpec instances.
-        If 'args' is None, uses sys.argv[1:].
-        """
-        parser = cls.get_parser()
-        try:
-            parsed_args = parser.parse_args(args)
-        except SystemExit as e:
-            # Allow SystemExit (e.g., from --help) to propagate
-            raise e
-        # Assign parsed values from the namespace
-        cls.load_from_namespace(parsed_args)
-
-    @classmethod
-    def load_from_namespace(cls, args: argparse.Namespace) -> None:
-        """Assigns values from a parsed argparse.Namespace object to the ArgumentSpecs."""
-        for key, spec in cls.iter_specs():
-            # Determine the attribute name in the namespace
-            # Positional args use their name, optionals use the 'dest' (which is 'key')
-            is_positional = not any(name.startswith("-") for name in spec.name_or_flags)
-            attr_name = spec.name_or_flags[0] if is_positional else key
-            # Check if the attribute exists in the namespace
-            if not hasattr(args, attr_name):
-                continue
-
-            value: object = getattr(args, attr_name)
-            if value is argparse.SUPPRESS:
-                continue
-
-            # Assign the value unless it's the SUPPRESS sentinel
-            if argument_spec_type := cls.__argspectype__.get(key):
-                if argument_spec_type.should_return_as_list:
-                    if isinstance(value, list):
-                        value = typing.cast(List[object], value)
-                    elif value is not None:
-                        value = [value]
-                elif argument_spec_type.should_return_as_tuple:
-                    if isinstance(value, tuple):
-                        value = typing.cast(Tuple[object, ...], value)
-                    elif value is not None:
-                        if isinstance(value, list):
-                            value = tuple(typing.cast(List[object], value))
-                        else:
-                            value = (value,)
-            spec.value = value
-
-    @classmethod
-    def get_value(cls, key: str) -> Optional[object]:
-        """Retrieves the parsed value for a specific argument by its attribute name."""
-        if key in cls.__argspec__:
-            return cls.__argspec__[key].value
-        raise KeyError(f"Argument spec with key '{key}' not found.")
-
-    @classmethod
-    def get_all_values(cls) -> Dict[str, Optional[object]]:
-        """Returns a dictionary of all argument attribute names and their parsed values."""
-        return {key: spec.value for key, spec in cls.iter_specs()}
-
-    def __init__(self) -> None:
-        self.load()
-
-
-def get_args(t: object) -> Tuple[object, ...]:
-    """Returns the arguments of a type or a generic type."""
-    return typing.get_args(t)
-
-
-def get_origin(t: object) -> typing.Optional[object]:
-    """Returns the origin of a type or a generic type."""
-    return typing.get_origin(t)
-
-
-# --- Main execution block (Example Usage) ---
-if __name__ == "__main__":
-
-    class __Arguments(BaseArguments):
-        """Example argument parser demonstrating various features."""
-
-        my_str_arg: ArgumentSpec[str] = ArgumentSpec(
-            ["-s", "--string-arg"], default="Hello", help="A string argument.", metavar="TEXT"
-        )
-        my_int_arg: ArgumentSpec[int] = ArgumentSpec(
-            ["-i", "--integer-arg"], required=True, help="A required integer argument."
-        )
-        verbose: ArgumentSpec[bool] = ArgumentSpec(
-            ["-v", "--verbose"], action="store_true", help="Increase output verbosity."
-        )
-        # --- List<str> ---
-        my_list_arg: ArgumentSpec[List[str]] = ArgumentSpec(
-            ["--list-values"],
-            nargs="+",
-            help="One or more string values.",
-            default=None,
-        )
-        # --- Positional IO ---
-        input_file: ArgumentSpec[IO[str]] = ArgumentSpec(
-            ["input_file"],
-            type=argparse.FileType("r", encoding="utf-8"),
-            help="Path to the input file (required).",
-            metavar="INPUT_PATH",
-        )
-        output_file: ArgumentSpec[Optional[IO[str]]] = ArgumentSpec(
-            ["output_file"],
-            type=argparse.FileType("w", encoding="utf-8"),
-            nargs="?",
-            default=None,
-            help="Optional output file path.",
-            metavar="OUTPUT_PATH",
-        )
-        # --- Simple Literal (choices auto-detected) ---
-        log_level: ArgumentSpec[Literal["DEBUG", "INFO", "WARNING", "ERROR"]] = ArgumentSpec(
-            ["--log-level"],
-            default="INFO",
-            help="Set the logging level.",
-        )
-        # --- Literal + explicit choices (explicit wins) ---
-        mode: ArgumentSpec[Literal["fast", "slow", "careful"]] = ArgumentSpec(
-            ["--mode"],
-            choices=["fast", "slow"],  # Explicit choices override Literal args
-            default="fast",
-            help="Operation mode.",
-        )
-        # --- List[Literal] (choices auto-detected) ---
-        enabled_features: ArgumentSpec[List[Literal["CACHE", "LOGGING", "RETRY"]]] = ArgumentSpec(
-            ["--features"],
-            nargs="*",  # 0 or more features
-            help="Enable specific features.",
-            default=[],
-        )
-        tuple_features: ArgumentSpec[
-            Tuple[Literal["CACHE", "LOGGING", "RETRY"], Literal["CAwCHE", "LOGGING", "RETRY"]]
-        ] = ArgumentSpec(
-            ["--tuple-features"],
-            help="Enable specific features (tuple).",
-        )
-
-        # --- SUPPRESS default ---
-        optional_flag: ArgumentSpec[str] = ArgumentSpec(
-            ["--opt-flag"],
-            default=SUPPRESS,
-            help="An optional flag whose attribute might not be set.",
-        )
-
-    print("--- Initial State (Before Parsing) ---")
-    parser_for_debug = __Arguments.get_parser()
-    for k, s in __Arguments.iter_specs():
-        print(f"{k}: value={s.value}, type={s.type}, choices={s.choices}")  # Check inferred choices
-
-    dummy_input_filename = "temp_input_for_argparse_test.txt"
-    try:
-        with open(dummy_input_filename, "w", encoding="utf-8") as f:
-            f.write("This is a test file.\n")
-        print(f"\nCreated dummy input file: {dummy_input_filename}")
-    except Exception as e:
-        print(f"Warning: Could not create dummy input file '{dummy_input_filename}': {e}")
-
-    # Example command-line arguments (Adjusted order)
-    test_args = [
-        dummy_input_filename,
-        "-i",
-        "42",
-        "--log-level",
-        "WARNING",
-        "--mode",
-        "slow",
-        "--list-values",
-        "apple",
-        "banana",
-        "--features",
-        "CACHE",
-        "RETRY",  # Test List[Literal]
-        "--tuple-features",
-        "CACHE",
-        "LOGGING",  # Test Tuple[Literal]
-    ]
-    # test_args = ['--features', 'INVALID'] # Test invalid choice for List[Literal]
-    # test_args = ['-h']
-
-    try:
-        print(f"\n--- Loading Arguments (Args: {test_args if test_args else 'from sys.argv'}) ---")
-        __Arguments.load(test_args)
-        print("\n--- Final Loaded Arguments ---")
-        all_values = __Arguments.get_all_values()
-        for key, value in all_values.items():
-            value_type = type(value).__name__
-            if isinstance(value, io.IOBase):
-                try:
-                    name = getattr(value, "name", "<unknown_name>")
-                    mode = getattr(value, "mode", "?")
-                    value_repr = f"<IO {name} mode='{mode}'>"
-                except ValueError:
-                    value_repr = "<IO object (closed)>"
-            else:
-                value_repr = repr(value)
-            print(f"{key}: {value_repr} (Type: {value_type})")
-
-        print("\n--- Accessing Specific Values ---")
-        print(f"Features     : {__Arguments.get_value('enabled_features')}")  # Check List[Literal] value
-
-        input_f = __Arguments.get_value("input_file")
-        if isinstance(input_f, io.IOBase):
-            try:
-                print(f"\nReading from input file: {input_f.name}")  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
-                input_f.close()
-                print(f"Closed input file: {input_f.name}")  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
-            except Exception as e:
-                print(f"Error processing input file: {e}")
-
-    except SystemExit as e:
-        print(f"\nExiting application (SystemExit code: {e.code}).")
-    except FileNotFoundError as e:
-        print(f"\nError: Required file not found: {e.filename}")
-        parser_for_debug.print_usage()
-    except Exception as e:
-        print(f"\nAn unexpected error occurred: {e}")
-        import traceback
-
-        traceback.print_exc()
-    finally:
-        import os
-
-        if os.path.exists(dummy_input_filename):
-            try:
-                os.remove(dummy_input_filename)
-                print(f"\nRemoved dummy input file: {dummy_input_filename}")
-            except Exception as e:
-                print(f"Warning: Could not remove dummy file '{dummy_input_filename}': {e}")

chatterer-0.1.14.dist-info/RECORD

@@ -1,34 +0,0 @@
-chatterer/__init__.py,sha256=Mxt_qGUyLEbbJ3VU-qr1EBgE2tSNFvqxiL-1QcXLu2c,2252
-chatterer/interactive.py,sha256=4_XKcdpRNLWEbEXwszJG-sECGun7_U1tEhd30brUPZM,16784
-chatterer/language_model.py,sha256=L3mVbbtiRoUx1UfJy0gCJ4laf03nyfDiDQtbEcB5Nv0,17594
-chatterer/messages.py,sha256=SIvG9hMHaPG4AFadeRbj5yPnMq2J06fHA4D8jrkz4kQ,458
-chatterer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chatterer/common_types/__init__.py,sha256=Ais0kqzQJj4sED24xdv5azIxHkkj0vXWb4LC41dFkBQ,355
-chatterer/common_types/io.py,sha256=GBZVhcRRCNZTAC1OPKAwW4s3EiyYRmNZ0ZWD1DxgMzs,798
-chatterer/strategies/__init__.py,sha256=oroDpp5ppWralCER5wnf8fgX77dqLAPF0ogmRtRzQfU,208
-chatterer/strategies/atom_of_thoughts.py,sha256=g801rY7k5UeNOq2-XRqB4h8sXjikVNzN57G6OtiUH00,39897
-chatterer/strategies/base.py,sha256=rqOzTo6S2eQ3A_F9aBXCmVoLM1eT6F2VzZ2Dof330Tk,413
-chatterer/tools/__init__.py,sha256=cOFo-Aj2xXK_7IvWYRdg6uNomaT9xuSa_mwk2Y0l_AM,1428
-chatterer/tools/caption_markdown_images.py,sha256=PfvHvr7x0XRLKlujALvOfEB3pQmjzlYFbcJqw2NHgZs,15008
-chatterer/tools/convert_pdf_to_markdown.py,sha256=prvgMvR3IPWopSVKfSIQRtnJNGnWUxLCwqXEgc6gcDA,14688
-chatterer/tools/convert_to_text.py,sha256=fMxUt7F6iMLf5tyZNNjhCxyW1zk7a6lTkDVe8YNS6XU,14996
-chatterer/tools/upstage_document_parser.py,sha256=xiXDUA95U0tAtxzVWcHHBHD72_TVmch-dg_QPmGNOGw,32398
-chatterer/tools/webpage_to_markdown.py,sha256=E9ZTg7fC6Z0dzGuYEsokRyzb8WVhiWdGFlQdiNSrBQ0,31222
-chatterer/tools/youtube.py,sha256=vrsf6pK6D6UBQQCiNUkE5Xe0VQ3SadoEnyAzGwhElX4,5935
-chatterer/tools/citation_chunking/__init__.py,sha256=DyLMGG4dVgSnGIdaSHcBNDz09iXflcKuJCtg4W0JTVo,79
-chatterer/tools/citation_chunking/chunks.py,sha256=_Sxzfbud8XTOHdHdQmKwm4-byES1cD1V6C28DgtS1BA,2120
-chatterer/tools/citation_chunking/citation_chunker.py,sha256=Aye1BqUCa4u_CsTZoqCe72pJA8C_y2U5UR7cNoNpeo4,4776
-chatterer/tools/citation_chunking/citations.py,sha256=BWhSwzZccvu0Db-OxEbsuEGEz-Dh_tXo8HRx1y2XUHg,12308
-chatterer/tools/citation_chunking/prompt.py,sha256=so-8uFQ5b2Zq2V5Brfxd76bEnKYkHovYsohAnbxWEnY,7557
-chatterer/tools/citation_chunking/reference.py,sha256=m47XYaB5uFff_x_k7US9hNr-SpZjKnl-GuzsGaQzcZo,893
-chatterer/tools/citation_chunking/utils.py,sha256=Xytm9lMrS783Po1qWAdEJ8q7Q3l2UMzwHd9EkYTRiwk,6210
-chatterer/utils/__init__.py,sha256=wA_nd1si3MbypA4biQRa3MYBqkHwTSCioYgaHce42Ls,412
-chatterer/utils/base64_image.py,sha256=w5SQoHVPDEQtFSUhV1l9GKg-IQy1WK5nyjv9k0upow8,10839
-chatterer/utils/bytesio.py,sha256=QabdJCZsabPaiYVfJcdXzdiHjuhqDlz1vJuLJ60P7TY,2559
-chatterer/utils/cli.py,sha256=F-Ooz4_pFeX4Y36R7OGhNrE7-IDyVIv2EEelYwJ4H0Y,19392
-chatterer/utils/code_agent.py,sha256=3Wu0M6VvfvWKu4UUoJ0rV-WjvLj06r15_01vft3d1Ns,10231
-chatterer/utils/imghdr.py,sha256=aZ1_AsRzyTsbV7uoeAZMVaC-hj73kvnFHMdHtFKskdE,3694
-chatterer-0.1.14.dist-info/METADATA,sha256=nMitUtZcmWPpmwVl_MTuzvK_AK-t6CuFlsdIxiSmbfA,11267
-chatterer-0.1.14.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-chatterer-0.1.14.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
-chatterer-0.1.14.dist-info/RECORD,,