chatterer 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

chatterer/__init__.py

@@ -1,93 +1,93 @@
-from .interactive import interactive_shell
-from .language_model import Chatterer
-from .messages import (
-    AIMessage,
-    BaseMessage,
-    BaseMessageChunk,
-    FunctionMessage,
-    HumanMessage,
-    LanguageModelInput,
-    SystemMessage,
-    UsageMetadata,
-)
-from .strategies import (
-    AoTPipeline,
-    AoTPrompter,
-    AoTStrategy,
-    BaseStrategy,
-)
-from .tools import (
-    CodeSnippets,
-    MarkdownLink,
-    PdfToMarkdown,
-    PlayWrightBot,
-    PlaywrightLaunchOptions,
-    PlaywrightOptions,
-    PlaywrightPersistencyOptions,
-    UpstageDocumentParseParser,
-    acaption_markdown_images,
-    anything_to_markdown,
-    caption_markdown_images,
-    citation_chunker,
-    extract_text_from_pdf,
-    get_default_html_to_markdown_options,
-    get_default_playwright_launch_options,
-    get_youtube_video_details,
-    get_youtube_video_subtitle,
-    html_to_markdown,
-    open_pdf,
-    pdf_to_text,
-    pyscripts_to_snippets,
-    render_pdf_as_image,
-)
-from .utils import (
-    Base64Image,
-    CodeExecutionResult,
-    FunctionSignature,
-    get_default_repl_tool,
-    insert_callables_into_global,
-)
-
-__all__ = [
-    "BaseStrategy",
-    "Chatterer",
-    "AoTStrategy",
-    "AoTPipeline",
-    "AoTPrompter",
-    "html_to_markdown",
-    "anything_to_markdown",
-    "pdf_to_text",
-    "get_default_html_to_markdown_options",
-    "pyscripts_to_snippets",
-    "citation_chunker",
-    "BaseMessage",
-    "HumanMessage",
-    "SystemMessage",
-    "AIMessage",
-    "FunctionMessage",
-    "Base64Image",
-    "FunctionSignature",
-    "CodeExecutionResult",
-    "get_default_repl_tool",
-    "insert_callables_into_global",
-    "get_youtube_video_subtitle",
-    "get_youtube_video_details",
-    "interactive_shell",
-    "UpstageDocumentParseParser",
-    "BaseMessageChunk",
-    "CodeSnippets",
-    "LanguageModelInput",
-    "UsageMetadata",
-    "PlayWrightBot",
-    "PlaywrightLaunchOptions",
-    "PlaywrightOptions",
-    "PlaywrightPersistencyOptions",
-    "get_default_playwright_launch_options",
-    "acaption_markdown_images",
-    "caption_markdown_images",
-    "MarkdownLink",
-    "PdfToMarkdown",
-    "extract_text_from_pdf",
-    "open_pdf",
-    "render_pdf_as_image",
-]
+from .interactive import interactive_shell
+from .language_model import Chatterer
+from .messages import (
+    AIMessage,
+    BaseMessage,
+    BaseMessageChunk,
+    FunctionMessage,
+    HumanMessage,
+    LanguageModelInput,
+    SystemMessage,
+    UsageMetadata,
+)
+from .strategies import (
+    AoTPipeline,
+    AoTPrompter,
+    AoTStrategy,
+    BaseStrategy,
+)
+from .tools import (
+    CodeSnippets,
+    MarkdownLink,
+    PdfToMarkdown,
+    PlayWrightBot,
+    PlaywrightLaunchOptions,
+    PlaywrightOptions,
+    PlaywrightPersistencyOptions,
+    UpstageDocumentParseParser,
+    acaption_markdown_images,
+    anything_to_markdown,
+    caption_markdown_images,
+    citation_chunker,
+    extract_text_from_pdf,
+    get_default_html_to_markdown_options,
+    get_default_playwright_launch_options,
+    get_youtube_video_details,
+    get_youtube_video_subtitle,
+    html_to_markdown,
+    open_pdf,
+    pdf_to_text,
+    pyscripts_to_snippets,
+    render_pdf_as_image,
+)
+from .utils import (
+    Base64Image,
+    CodeExecutionResult,
+    FunctionSignature,
+    get_default_repl_tool,
+    insert_callables_into_global,
+)
+
+__all__ = [
+    "BaseStrategy",
+    "Chatterer",
+    "AoTStrategy",
+    "AoTPipeline",
+    "AoTPrompter",
+    "html_to_markdown",
+    "anything_to_markdown",
+    "pdf_to_text",
+    "get_default_html_to_markdown_options",
+    "pyscripts_to_snippets",
+    "citation_chunker",
+    "BaseMessage",
+    "HumanMessage",
+    "SystemMessage",
+    "AIMessage",
+    "FunctionMessage",
+    "Base64Image",
+    "FunctionSignature",
+    "CodeExecutionResult",
+    "get_default_repl_tool",
+    "insert_callables_into_global",
+    "get_youtube_video_subtitle",
+    "get_youtube_video_details",
+    "interactive_shell",
+    "UpstageDocumentParseParser",
+    "BaseMessageChunk",
+    "CodeSnippets",
+    "LanguageModelInput",
+    "UsageMetadata",
+    "PlayWrightBot",
+    "PlaywrightLaunchOptions",
+    "PlaywrightOptions",
+    "PlaywrightPersistencyOptions",
+    "get_default_playwright_launch_options",
+    "acaption_markdown_images",
+    "caption_markdown_images",
+    "MarkdownLink",
+    "PdfToMarkdown",
+    "extract_text_from_pdf",
+    "open_pdf",
+    "render_pdf_as_image",
+]

chatterer/common_types/__init__.py

@@ -1,21 +1,21 @@
-from .io import (
-    BytesReadable,
-    BytesWritable,
-    FileDescriptorOrPath,
-    PathOrReadable,
-    Readable,
-    StringReadable,
-    StringWritable,
-    Writable,
-)
-
-__all__ = [
-    "BytesReadable",
-    "BytesWritable",
-    "FileDescriptorOrPath",
-    "PathOrReadable",
-    "Readable",
-    "StringReadable",
-    "StringWritable",
-    "Writable",
-]
+from .io import (
+    BytesReadable,
+    BytesWritable,
+    FileDescriptorOrPath,
+    PathOrReadable,
+    Readable,
+    StringReadable,
+    StringWritable,
+    Writable,
+)
+
+__all__ = [
+    "BytesReadable",
+    "BytesWritable",
+    "FileDescriptorOrPath",
+    "PathOrReadable",
+    "Readable",
+    "StringReadable",
+    "StringWritable",
+    "Writable",
+]

chatterer/common_types/io.py

@@ -1,19 +1,19 @@
-import os
-from io import BufferedReader, BufferedWriter, BytesIO, StringIO, TextIOWrapper
-from typing import TypeAlias
-
-# Type aliases for callback functions and file descriptors
-FileDescriptorOrPath: TypeAlias = int | str | bytes | os.PathLike[str] | os.PathLike[bytes]
-
-# Type aliases for different types of IO objects
-BytesReadable: TypeAlias = BytesIO | BufferedReader
-BytesWritable: TypeAlias = BytesIO | BufferedWriter
-StringReadable: TypeAlias = StringIO | TextIOWrapper
-StringWritable: TypeAlias = StringIO | TextIOWrapper
-
-# Combined type aliases for readable and writable objects
-Readable: TypeAlias = BytesReadable | StringReadable
-Writable: TypeAlias = BytesWritable | StringWritable
-
-# Type alias for path or readable object
-PathOrReadable: TypeAlias = FileDescriptorOrPath | Readable
+import os
+from io import BufferedReader, BufferedWriter, BytesIO, StringIO, TextIOWrapper
+from typing import TypeAlias
+
+# Type aliases for callback functions and file descriptors
+FileDescriptorOrPath: TypeAlias = int | str | bytes | os.PathLike[str] | os.PathLike[bytes]
+
+# Type aliases for different types of IO objects
+BytesReadable: TypeAlias = BytesIO | BufferedReader
+BytesWritable: TypeAlias = BytesIO | BufferedWriter
+StringReadable: TypeAlias = StringIO | TextIOWrapper
+StringWritable: TypeAlias = StringIO | TextIOWrapper
+
+# Combined type aliases for readable and writable objects
+Readable: TypeAlias = BytesReadable | StringReadable
+Writable: TypeAlias = BytesWritable | StringWritable
+
+# Type alias for path or readable object
+PathOrReadable: TypeAlias = FileDescriptorOrPath | Readable

chatterer/examples/anything_to_markdown.py

@@ -1,91 +1,85 @@
-def resolve_import_path_and_get_logger():
-    # ruff: noqa: E402
-    import logging
-    import sys
-
-    if __name__ == "__main__" and "." not in sys.path:
-        sys.path.append(".")
-
-    logger = logging.getLogger(__name__)
-    return logger
-
-
-logger = resolve_import_path_and_get_logger()
-from pathlib import Path
-from typing import Optional, TypedDict
-
-import openai
-from spargear import ArgumentSpec, BaseArguments
-
-from chatterer import anything_to_markdown
-
-
-class AnythingToMarkdownReturns(TypedDict):
-    in_path: str
-    out_path: Optional[str]
-    out_text: str
-
-
-class AnythingToMarkdownArguments(BaseArguments):
-    """Command line arguments for converting various file types to markdown."""
-
-    in_path: ArgumentSpec[str] = ArgumentSpec(["in-path"], help="Input file to convert to markdown")
-    out_path: Optional[str] = None
-    """Output path for the converted markdown file. If not provided, the input file's suffix is replaced with .md"""
-    model: Optional[str] = None
-    """OpenAI Model to use for conversion"""
-    api_key: Optional[str] = None
-    """API key for OpenAI API"""
-    base_url: Optional[str] = None
-    """Base URL for OpenAI API"""
-    style_map: Optional[str] = None
-    """Output style map"""
-    exiftool_path: Optional[str] = None
-    """"Path to exiftool for metadata extraction"""
-    docintel_endpoint: Optional[str] = None
-    "Document Intelligence API endpoint"
-    prevent_save_file: bool = False
-    """Prevent saving the converted file to disk."""
-    encoding: str = "utf-8"
-    """Encoding for the output file."""
-
-    def run(self) -> AnythingToMarkdownReturns:
-        in_path = self.in_path.unwrap()
-        if not self.prevent_save_file:
-            if not self.out_path:
-                out_path = Path(in_path).with_suffix(".md")
-            else:
-                out_path = Path(self.out_path)
-        else:
-            out_path = None
-
-        if self.model:
-            llm_client = openai.OpenAI(api_key=self.api_key, base_url=self.base_url)
-            llm_model = self.model
-        else:
-            llm_client = None
-            llm_model = None
-
-        text: str = anything_to_markdown(
-            in_path,
-            llm_client=llm_client,
-            llm_model=llm_model,
-            style_map=self.style_map,
-            exiftool_path=self.exiftool_path,
-            docintel_endpoint=self.docintel_endpoint,
-        )
-        if out_path:
-            out_path.parent.mkdir(parents=True, exist_ok=True)
-            out_path.write_text(text, encoding=self.encoding)
-            logger.info(f"Converted `{in_path}` to markdown and saved to `{out_path}`.")
-        else:
-            logger.info(f"Converted `{in_path}` to markdown.")
-        return {
-            "in_path": in_path,
-            "out_path": str(out_path) if out_path is not None else None,
-            "out_text": text,
-        }
-
-
-if __name__ == "__main__":
-    AnythingToMarkdownArguments().run()
+import logging
+from pathlib import Path
+from typing import Optional, TypedDict
+
+import openai
+from spargear import BaseArguments
+
+from chatterer import anything_to_markdown
+
+logger = logging.getLogger(__name__)
+
+
+class AnythingToMarkdownReturns(TypedDict):
+    input: str
+    output: Optional[str]
+    out_text: str
+
+
+class AnythingToMarkdownArguments(BaseArguments):
+    """Command line arguments for converting various file types to markdown."""
+
+    input: str
+    """Input file to convert to markdown. Can be a file path or a URL."""
+    output: Optional[str] = None
+    """Output path for the converted markdown file. If not provided, the input file's suffix is replaced with .md"""
+    model: Optional[str] = None
+    """OpenAI Model to use for conversion"""
+    api_key: Optional[str] = None
+    """API key for OpenAI API"""
+    base_url: Optional[str] = None
+    """Base URL for OpenAI API"""
+    style_map: Optional[str] = None
+    """Output style map"""
+    exiftool_path: Optional[str] = None
+    """"Path to exiftool for metadata extraction"""
+    docintel_endpoint: Optional[str] = None
+    "Document Intelligence API endpoint"
+    prevent_save_file: bool = False
+    """Prevent saving the converted file to disk."""
+    encoding: str = "utf-8"
+    """Encoding for the output file."""
+
+    def run(self) -> AnythingToMarkdownReturns:
+        if not self.prevent_save_file:
+            if not self.output:
+                output = Path(self.input).with_suffix(".md")
+            else:
+                output = Path(self.output)
+        else:
+            output = None
+
+        if self.model:
+            llm_client = openai.OpenAI(api_key=self.api_key, base_url=self.base_url)
+            llm_model = self.model
+        else:
+            llm_client = None
+            llm_model = None
+
+        text: str = anything_to_markdown(
+            self.input,
+            llm_client=llm_client,
+            llm_model=llm_model,
+            style_map=self.style_map,
+            exiftool_path=self.exiftool_path,
+            docintel_endpoint=self.docintel_endpoint,
+        )
+        if output:
+            output.parent.mkdir(parents=True, exist_ok=True)
+            output.write_text(text, encoding=self.encoding)
+            logger.info(f"Converted `{self.input}` to markdown and saved to `{output}`.")
+        else:
+            logger.info(f"Converted `{self.input}` to markdown.")
+        return {
+            "input": self.input,
+            "output": str(output) if output is not None else None,
+            "out_text": text,
+        }
+
+
+def main() -> None:
+    AnythingToMarkdownArguments().run()
+
+
+if __name__ == "__main__":
+    main()

chatterer/examples/get_code_snippets.py

@@ -1,62 +1,55 @@
-def resolve_import_path_and_get_logger():
-    # ruff: noqa: E402
-    import logging
-    import sys
-
-    if __name__ == "__main__" and "." not in sys.path:
-        sys.path.append(".")
-
-    logger = logging.getLogger(__name__)
-    return logger
-
-
-logger = resolve_import_path_and_get_logger()
-from pathlib import Path
-from typing import Optional
-
-from spargear import ArgumentSpec, BaseArguments
-
-from chatterer import CodeSnippets
-
-
-class GetCodeSnippetsArgs(BaseArguments):
-    path_or_pkgname: ArgumentSpec[str] = ArgumentSpec(
-        ["path_or_pkgname"], help="Path to the package or file from which to extract code snippets."
-    )
-    out_path: Optional[str] = None
-    ban_file_patterns: list[str] = [".venv/*", Path(__file__).relative_to(Path.cwd()).as_posix()]
-    """List of file patterns to ignore."""
-    glob_patterns: list[str] = ["*.py"]
-    """List of glob patterns to include."""
-    case_sensitive: bool = False
-    """Enable case-sensitive matching for glob patterns."""
-    prevent_save_file: bool = False
-    """Prevent saving the extracted code snippets to a file."""
-
-    def run(self) -> CodeSnippets:
-        path_or_pkgname = self.path_or_pkgname.unwrap()
-        if not self.prevent_save_file:
-            if not self.out_path:
-                out_path = Path(__file__).with_suffix(".txt")
-            else:
-                out_path = Path(self.out_path)
-        else:
-            out_path = None
-
-        cs = CodeSnippets.from_path_or_pkgname(
-            path_or_pkgname=path_or_pkgname,
-            ban_file_patterns=self.ban_file_patterns,
-            glob_patterns=self.glob_patterns,
-            case_sensitive=self.case_sensitive,
-        )
-        if out_path is not None:
-            out_path.parent.mkdir(parents=True, exist_ok=True)
-            out_path.write_text(cs.snippets_text, encoding="utf-8")
-            logger.info(f"Extracted code snippets from `{path_or_pkgname}` and saved to `{out_path}`.")
-        else:
-            logger.info(f"Extracted code snippets from `{path_or_pkgname}`.")
-        return cs
-
-
-if __name__ == "__main__":
-    GetCodeSnippetsArgs().run()
+import logging
+from pathlib import Path
+from typing import Optional
+
+from spargear import BaseArguments
+
+from chatterer import CodeSnippets
+
+logger = logging.getLogger(__name__)
+
+
+class GetCodeSnippetsArgs(BaseArguments):
+    input: str
+    """Path to the package or file from which to extract code snippets."""
+    output: Optional[str] = None
+    """Output path for the extracted code snippets. If not provided, defaults to a file with the same name as the input."""
+    ban_file_patterns: list[str] = [".venv/*", Path(__file__).relative_to(Path.cwd()).as_posix()]
+    """List of file patterns to ignore."""
+    glob_patterns: list[str] = ["*.py"]
+    """List of glob patterns to include."""
+    case_sensitive: bool = False
+    """Enable case-sensitive matching for glob patterns."""
+    prevent_save_file: bool = False
+    """Prevent saving the extracted code snippets to a file."""
+
+    def run(self) -> CodeSnippets:
+        if not self.prevent_save_file:
+            if not self.output:
+                output = Path(__file__).with_suffix(".txt")
+            else:
+                output = Path(self.output)
+        else:
+            output = None
+
+        cs = CodeSnippets.from_path_or_pkgname(
+            path_or_pkgname=self.input,
+            ban_file_patterns=self.ban_file_patterns,
+            glob_patterns=self.glob_patterns,
+            case_sensitive=self.case_sensitive,
+        )
+        if output is not None:
+            output.parent.mkdir(parents=True, exist_ok=True)
+            output.write_text(cs.snippets_text, encoding="utf-8")
+            logger.info(f"Extracted code snippets from `{self.input}` and saved to `{output}`.")
+        else:
+            logger.info(f"Extracted code snippets from `{self.input}`.")
+        return cs
+
+
+def main() -> None:
+    GetCodeSnippetsArgs().run()
+
+
+if __name__ == "__main__":
+    main()