chatterer 0.1.23__tar.gz → 0.1.24__tar.gz

{chatterer-0.1.23 → chatterer-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatterer
-Version: 0.1.23
+Version: 0.1.24
 Summary: The highest-level interface for various LLM APIs.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -11,10 +11,9 @@ Requires-Dist: pillow>=11.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
 Requires-Dist: colorama>=0.4.6
-Requires-Dist: spargear>=0.2.0
+Requires-Dist: spargear>=0.2.7
 Provides-Extra: dev
-Requires-Dist: neo4j-extension>=0.1.14; extra == "dev"
-Requires-Dist: ipykernel>=6.29.5; extra == "dev"
+Requires-Dist: pyright>=1.1.401; extra == "dev"
 Provides-Extra: conversion
 Requires-Dist: youtube-transcript-api>=1.0.3; extra == "conversion"
 Requires-Dist: chatterer[browser]; extra == "conversion"
@@ -34,12 +33,10 @@ Requires-Dist: mistune>=3.1.3; extra == "markdown"
 Provides-Extra: video
 Requires-Dist: pydub>=0.25.1; extra == "video"
 Provides-Extra: langchain
-Requires-Dist: chatterer[langchain-providers]; extra == "langchain"
+Requires-Dist: langchain-anthropic>=0.3.10; extra == "langchain"
+Requires-Dist: langchain-google-genai>=2.1.1; extra == "langchain"
+Requires-Dist: langchain-ollama>=0.3.0; extra == "langchain"
 Requires-Dist: langchain-experimental>=0.3.4; extra == "langchain"
-Provides-Extra: langchain-providers
-Requires-Dist: langchain-anthropic>=0.3.10; extra == "langchain-providers"
-Requires-Dist: langchain-google-genai>=2.1.1; extra == "langchain-providers"
-Requires-Dist: langchain-ollama>=0.3.0; extra == "langchain-providers"
 Provides-Extra: all
 Requires-Dist: chatterer[dev]; extra == "all"
 Requires-Dist: chatterer[langchain]; extra == "all"

chatterer-0.1.24/chatterer/examples/__main__.py

@@ -0,0 +1,75 @@
+from spargear import SubcommandArguments, SubcommandSpec
+
+
+def any2md():
+    from .any2md import Arguments
+
+    return Arguments
+
+
+def pdf2md():
+    from .pdf2md import Arguments
+
+    return Arguments
+
+
+def pdf2txt():
+    from .pdf2txt import Arguments
+
+    return Arguments
+
+
+def ppt():
+    from .ppt import Arguments
+
+    return Arguments
+
+
+def pw():
+    from .pw import Arguments
+
+    return Arguments
+
+
+def snippet():
+    from .snippet import Arguments
+
+    return Arguments
+
+
+def transcribe():
+    from .transcribe import Arguments
+
+    return Arguments
+
+
+def upstage():
+    from .upstage import Arguments
+
+    return Arguments
+
+
+def web2md():
+    from .web2md import Arguments
+
+    return Arguments
+
+
+class Arguments(SubcommandArguments):
+    any2md = SubcommandSpec(name="any2md", argument_class_factory=any2md)
+    pdf2md = SubcommandSpec(name="pdf2md", argument_class_factory=pdf2md)
+    pdf2txt = SubcommandSpec(name="pdf2txt", argument_class_factory=pdf2txt)
+    ppt = SubcommandSpec(name="ppt", argument_class_factory=ppt)
+    pw = SubcommandSpec(name="pw", argument_class_factory=pw)
+    snippet = SubcommandSpec(name="snippet", argument_class_factory=snippet)
+    transcribe = SubcommandSpec(name="transcribe", argument_class_factory=transcribe)
+    upstage = SubcommandSpec(name="upstage", argument_class_factory=upstage)
+    web2md = SubcommandSpec(name="web2md", argument_class_factory=web2md)
+
+
+def main():
+    Arguments().execute()
+
+
+if __name__ == "__main__":
+    main()

chatterer-0.1.23/chatterer/examples/anything_to_markdown.py → chatterer-0.1.24/chatterer/examples/any2md.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from typing import Optional, TypedDict
 
 import openai
-from spargear import BaseArguments
+from spargear import RunnableArguments
 
 from chatterer import anything_to_markdown
 
@@ -16,10 +16,10 @@ class AnythingToMarkdownReturns(TypedDict):
     out_text: str
 
 
-class AnythingToMarkdownArguments(BaseArguments):
+class Arguments(RunnableArguments[AnythingToMarkdownReturns]):
     """Command line arguments for converting various file types to markdown."""
 
-    input: str
+    SOURCE: 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"""
@@ -43,7 +43,7 @@ class AnythingToMarkdownArguments(BaseArguments):
     def run(self) -> AnythingToMarkdownReturns:
         if not self.prevent_save_file:
             if not self.output:
-                output = Path(self.input).with_suffix(".md")
+                output = Path(self.SOURCE).with_suffix(".md")
             else:
                 output = Path(self.output)
         else:
@@ -57,7 +57,7 @@ class AnythingToMarkdownArguments(BaseArguments):
             llm_model = None
 
         text: str = anything_to_markdown(
-            self.input,
+            self.SOURCE,
             llm_client=llm_client,
             llm_model=llm_model,
             style_map=self.style_map,
@@ -67,18 +67,18 @@ class AnythingToMarkdownArguments(BaseArguments):
         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}`.")
+            logger.info(f"Converted `{self.SOURCE}` to markdown and saved to `{output}`.")
         else:
-            logger.info(f"Converted `{self.input}` to markdown.")
+            logger.info(f"Converted `{self.SOURCE}` to markdown.")
         return {
-            "input": self.input,
+            "input": self.SOURCE,
             "output": str(output) if output is not None else None,
             "out_text": text,
         }
 
 
 def main() -> None:
-    AnythingToMarkdownArguments().run()
+    Arguments().run()
 
 
 if __name__ == "__main__":

chatterer-0.1.23/chatterer/examples/pdf_to_markdown.py → chatterer-0.1.24/chatterer/examples/pdf2md.py

@@ -13,7 +13,7 @@ import time
 from pathlib import Path
 from typing import List, Literal, Optional, TypedDict
 
-from spargear import ArgumentSpec, BaseArguments
+from spargear import ArgumentSpec, RunnableArguments
 
 from chatterer import Chatterer
 from chatterer.tools.convert_pdf_to_markdown import PdfToMarkdown
@@ -35,10 +35,10 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(level
 logger = logging.getLogger(__name__)
 
 
-class PdfToMarkdownArgs(BaseArguments):
+class Arguments(RunnableArguments[List[ConversionResult]]):
     """Command-line arguments for PDF to Markdown conversion."""
 
-    input: str
+    PDF_OR_DIRECTORY_PATH: str
     """Input PDF file or directory containing PDF files to convert to markdown."""
 
     output: Optional[str] = None
@@ -274,7 +274,7 @@ class PdfToMarkdownArgs(BaseArguments):
 
     def _prepare_files(self) -> tuple[List[Path], Path, bool]:
         """Prepare input and output file paths."""
-        input_path = Path(self.input).resolve()
+        input_path = Path(self.PDF_OR_DIRECTORY_PATH).resolve()
         pdf_files: List[Path] = []
         is_dir = False
 
@@ -320,7 +320,7 @@ def main() -> None:
     """Main entry point for the CLI application."""
     args = None
     try:
-        args = PdfToMarkdownArgs()
+        args = Arguments()
         args.run()
     except KeyboardInterrupt:
         logger.info("🛑 Conversion interrupted by user")

chatterer-0.1.23/chatterer/examples/pdf_to_text.py → chatterer-0.1.24/chatterer/examples/pdf2txt.py

@@ -3,15 +3,15 @@ import sys
 from pathlib import Path
 from typing import Optional
 
-from spargear import BaseArguments
+from spargear import RunnableArguments
 
 from chatterer.tools.convert_to_text import pdf_to_text
 
 logger = logging.getLogger(__name__)
 
 
-class PdfToTextArgs(BaseArguments):
-    input: Path
+class Arguments(RunnableArguments[None]):
+    PDF_PATH: Path
     """Path to the PDF file to convert to text."""
     output: Optional[Path]
     """Path to the output text file. If not provided, defaults to the input file with a .txt suffix."""
@@ -19,7 +19,7 @@ class PdfToTextArgs(BaseArguments):
     """Comma-separated list of zero-based page indices to extract from the PDF. Supports ranges, e.g., '0,2,4-8'."""
 
     def run(self) -> None:
-        input = self.input.resolve()
+        input = self.PDF_PATH.resolve()
         out = self.output or input.with_suffix(".txt")
         if not input.is_file():
             sys.exit(1)
@@ -47,7 +47,7 @@ def parse_page_indices(pages_str: str) -> list[int]:
 
 
 def main() -> None:
-    PdfToTextArgs().run()
+    Arguments().run()
 
 
 if __name__ == "__main__":

chatterer-0.1.23/chatterer/examples/make_ppt.py → chatterer-0.1.24/chatterer/examples/ppt.py

@@ -3,7 +3,7 @@ import sys
 from pathlib import Path
 from typing import NotRequired, TypedDict
 
-from spargear import BaseArguments
+from spargear import RunnableArguments
 
 from chatterer import BaseMessage, Chatterer, HumanMessage, SystemMessage
 
@@ -155,7 +155,7 @@ Now, generate the final `presentation.html` file using impress.js and the provid
 # --- Argument Parsing ---
 
 
-class MakePptArguments(BaseArguments):
+class Arguments(RunnableArguments[None]):
     """
     Arguments for the presentation generation process.
     """
@@ -179,9 +179,7 @@ class MakePptArguments(BaseArguments):
     """Prompt for organizing slides into a presentation script"""
 
     # LLM Settings
-    provider: str = (
-        "openai:gpt-4.1"  # Example: "openai:gpt-4o", "anthropic:claude-3-haiku-20240307", "google:gemini-1.5-flash"
-    )
+    provider: str = "openai:gpt-4.1"  # Example: "openai:gpt-4o", "anthropic:claude-3-haiku-20240307", "google:gemini-1.5-flash"
     """Name of the language model to use (provider:model_name)"""
 
     # Other settings
@@ -293,7 +291,7 @@ class GeneratedSlide(TypedDict):
     script: NotRequired[str]
 
 
-def run_presentation_agent(args: MakePptArguments):
+def run_presentation_agent(args: Arguments):
     """Executes the presentation generation agent loop."""
 
     if args.verbose:
@@ -481,7 +479,7 @@ Remember to follow all instructions in the role prompt, especially regarding HTM
 
 
 def main() -> None:
-    MakePptArguments().run()
+    Arguments().run()
 
 
 if __name__ == "__main__":

chatterer-0.1.24/chatterer/examples/pw.py

@@ -0,0 +1,137 @@
+import json
+import logging
+import sys
+from pathlib import Path
+
+from spargear import BaseArguments, RunnableArguments, SubcommandSpec
+
+from chatterer import PlayWrightBot
+
+logger = logging.getLogger(__name__)
+
+
+# Define the default path location relative to this script file
+DEFAULT_JSON_PATH = Path(__file__).resolve().parent / "session_state.json"
+
+
+class ReadArgs(RunnableArguments[None]):
+    """Arguments for the 'read' subcommand."""
+
+    URL: str
+    """URL (potentially protected) to navigate to using the saved session."""
+    jsonpath: Path = DEFAULT_JSON_PATH
+    """Path to the session state JSON file to load."""
+
+    def run(self) -> None:
+        """
+        Loads the session state from the specified JSON file, then navigates
+        to a protected_url that normally requires login. If the stored session
+        is valid, it should open without re-entering credentials.
+
+        Correction: Loads the JSON content into a dict first to satisfy type hints.
+        """
+        url = self.URL
+        jsonpath = self.jsonpath
+        logger.info(f"Loading session from {jsonpath} and navigating to {url} ...")
+
+        if not jsonpath.exists():
+            logger.error(f"Session file not found at {jsonpath}")
+            sys.exit(1)
+
+        # Load the storage state from the JSON file into a dictionary
+        logger.info(f"Reading storage state content from {jsonpath} ...")
+        try:
+            with open(jsonpath, "r", encoding="utf-8") as f:
+                # This dictionary should match the 'StorageState' type expected by Playwright/chatterer
+                storage_state_dict = json.load(f)
+        except json.JSONDecodeError:
+            logger.error(f"Failed to decode JSON from {jsonpath}")
+            sys.exit(1)
+        except Exception as e:
+            logger.error(f"Error reading file {jsonpath}: {e}")
+            sys.exit(1)
+
+        logger.info("Launching browser with loaded session state...")
+        with PlayWrightBot(
+            playwright_launch_options={"headless": False},
+            # Pass the loaded dictionary, which should match the expected 'StorageState' type
+            playwright_persistency_options={"storage_state": storage_state_dict},
+        ) as bot:
+            bot.get_page(url)
+
+            logger.info("Press Enter in the console when you're done checking the protected page.")
+            input("    >> Press Enter to exit: ")
+
+        logger.info("Done! Browser is now closed.")
+
+
+class WriteArgs(RunnableArguments[None]):
+    """Arguments for the 'write' subcommand."""
+
+    URL: str
+    """URL to navigate to for manual login."""
+    jsonpath: Path = DEFAULT_JSON_PATH
+    """Path to save the session state JSON file."""
+
+    def run(self) -> None:
+        """
+        Launches a non-headless browser and navigates to the login_url.
+        The user can manually log in, then press Enter in the console
+        to store the current session state into a JSON file.
+        """
+        url = self.URL
+        jsonpath = self.jsonpath
+        logger.info(f"Launching browser and navigating to {url} ... Please log in manually.")
+
+        # Ensure jsonpath directory exists
+        jsonpath.parent.mkdir(parents=True, exist_ok=True)
+
+        with PlayWrightBot(playwright_launch_options={"headless": False}) as bot:
+            bot.get_page(url)
+
+            logger.info("After completing the login in the browser, press Enter here to save the session.")
+            input("    >> Press Enter when ready: ")
+
+            # get_sync_browser() returns the BrowserContext internally
+            context = bot.get_sync_browser()
+
+            # Save the current session (cookies, localStorage) to a JSON file
+            logger.info(f"Saving storage state to {jsonpath} ...")
+            context.storage_state(path=jsonpath)  # Pass Path object directly
+
+        logger.info("Done! Browser is now closed.")
+
+
+class Arguments(BaseArguments):
+    """
+    A simple CLI tool for saving and using Playwright sessions via storage_state.
+    Uses spargear for declarative argument parsing.
+    """
+
+    read: SubcommandSpec[ReadArgs] = SubcommandSpec(
+        name="read",
+        argument_class=ReadArgs,
+        help="Use a saved session to view a protected page.",
+        description="Loads session state from the specified JSON file and navigates to the URL.",
+    )
+    write: SubcommandSpec[WriteArgs] = SubcommandSpec(
+        name="write",
+        argument_class=WriteArgs,
+        help="Save a new session by manually logging in.",
+        description="Launches a browser to the specified URL. Log in manually, then press Enter to save session state.",
+    )
+
+    def run(self) -> None:
+        """Parses arguments using spargear and executes the corresponding command."""
+        if isinstance(last_subcommand := self.last_command, RunnableArguments):
+            last_subcommand.run()
+        else:
+            self.get_parser().print_help()
+
+
+def main() -> None:
+    Arguments().run()
+
+
+if __name__ == "__main__":
+    main()

chatterer-0.1.23/chatterer/examples/get_code_snippets.py → chatterer-0.1.24/chatterer/examples/snippet.py

@@ -2,15 +2,15 @@ import logging
 from pathlib import Path
 from typing import Optional
 
-from spargear import BaseArguments
+from spargear import RunnableArguments
 
 from chatterer import CodeSnippets
 
 logger = logging.getLogger(__name__)
 
 
-class GetCodeSnippetsArgs(BaseArguments):
-    input: str
+class Arguments(RunnableArguments[CodeSnippets]):
+    PATH_OR_PACKAGE_NAME: 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."""
@@ -33,7 +33,7 @@ class GetCodeSnippetsArgs(BaseArguments):
             output = None
 
         cs = CodeSnippets.from_path_or_pkgname(
-            path_or_pkgname=self.input,
+            path_or_pkgname=self.PATH_OR_PACKAGE_NAME,
             ban_file_patterns=self.ban_file_patterns,
             glob_patterns=self.glob_patterns,
             case_sensitive=self.case_sensitive,
@@ -41,14 +41,14 @@ class GetCodeSnippetsArgs(BaseArguments):
         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}`.")
+            logger.info(f"Extracted code snippets from `{self.PATH_OR_PACKAGE_NAME}` and saved to `{output}`.")
         else:
-            logger.info(f"Extracted code snippets from `{self.input}`.")
+            logger.info(f"Extracted code snippets from `{self.PATH_OR_PACKAGE_NAME}`.")
         return cs
 
 
 def main() -> None:
-    GetCodeSnippetsArgs().run()
+    Arguments().run()
 
 
 if __name__ == "__main__":

chatterer-0.1.23/chatterer/examples/transcription_api.py → chatterer-0.1.24/chatterer/examples/transcribe.py

@@ -6,14 +6,14 @@ from typing import Optional, cast
 
 from openai import OpenAI
 from pydub import AudioSegment
-from spargear import BaseArguments
+from spargear import RunnableArguments
 
 # Maximum chunk length in seconds
 MAX_CHUNK_DURATION = 600
 
 
-class TranscriptionApiArguments(BaseArguments):
-    input: Path
+class Arguments(RunnableArguments[None]):
+    AUDIO_PATH: Path
     """The audio file to transcribe."""
     output: Optional[Path] = None
     """Path to save the transcription output."""
@@ -31,7 +31,7 @@ class TranscriptionApiArguments(BaseArguments):
 
         client = OpenAI(api_key=self.api_key, base_url=self.base_url)
 
-        audio = load_audio_segment(self.input)
+        audio = load_audio_segment(self.AUDIO_PATH)
 
         segments = split_audio(audio, MAX_CHUNK_DURATION)
         print(f"[i] Audio duration: {len(audio) / 1000:.1f}s; splitting into {len(segments)} segment(s)")
@@ -42,7 +42,7 @@ class TranscriptionApiArguments(BaseArguments):
             transcripts.append(transcribe_segment(seg, client, model, self.prompt))
 
         full_transcript = "\n\n".join(transcripts)
-        output_path: Path = self.output or self.input.with_suffix(".txt")
+        output_path: Path = self.output or self.AUDIO_PATH.with_suffix(".txt")
         output_path.write_text(full_transcript, encoding="utf-8")
         print(f"[✓] Transcription saved to: {output_path}")
 
@@ -105,7 +105,7 @@ def transcribe_segment(segment: AudioSegment, client: OpenAI, model: str, prompt
 
 
 def main() -> None:
-    TranscriptionApiArguments().run()
+    Arguments().run()
 
 
 if __name__ == "__main__":

chatterer-0.1.23/chatterer/examples/upstage_parser.py → chatterer-0.1.24/chatterer/examples/upstage.py

@@ -19,8 +19,8 @@ from chatterer.tools.upstage_document_parser import (
 logger = logging.getLogger(__name__)
 
 
-class UpstageParserArguments(BaseArguments):
-    input: Path
+class Arguments(BaseArguments):
+    INPUT_PATH: Path
     """Input file to parse. Can be a PDF, image, or other supported formats."""
     output: Optional[Path] = None
     """Output file path for the parsed content. Defaults to input file with .md suffix if not provided."""
@@ -52,25 +52,25 @@ class UpstageParserArguments(BaseArguments):
     )
 
     def run(self) -> None:
-        input = UpstageParserArguments.input.resolve()
-        out = UpstageParserArguments.output or input.with_suffix(".md")
+        input = self.INPUT_PATH.resolve()
+        out = self.output or input.with_suffix(".md")
 
         parser = UpstageDocumentParseParser(
-            api_key=UpstageParserArguments.api_key,
-            base_url=UpstageParserArguments.base_url,
-            model=UpstageParserArguments.model,
-            split=UpstageParserArguments.split,
-            ocr=UpstageParserArguments.ocr,
-            output_format=UpstageParserArguments.output_format,
-            coordinates=UpstageParserArguments.coordinates,
-            base64_encoding=UpstageParserArguments.base64_encoding,
-            image_description_instruction=UpstageParserArguments.image_description_instruction,
-            image_dir=UpstageParserArguments.image_dir,
-            chatterer=UpstageParserArguments.chatterer.value,
+            api_key=self.api_key,
+            base_url=self.base_url,
+            model=self.model,
+            split=self.split,
+            ocr=self.ocr,
+            output_format=self.output_format,
+            coordinates=self.coordinates,
+            base64_encoding=self.base64_encoding,
+            image_description_instruction=self.image_description_instruction,
+            image_dir=self.image_dir,
+            chatterer=self.chatterer.value,
         )
         docs = parser.parse(Blob.from_path(input))  # pyright: ignore[reportUnknownMemberType]
 
-        if UpstageParserArguments.image_dir:
+        if self.image_dir:
             for path, image in parser.image_data.items():
                 (path := Path(path)).parent.mkdir(parents=True, exist_ok=True)
                 path.write_bytes(image)
@@ -82,7 +82,7 @@ class UpstageParserArguments(BaseArguments):
 
 
 def main() -> None:
-    UpstageParserArguments().run()
+    Arguments().run()
 
 
 if __name__ == "__main__":

chatterer-0.1.23/chatterer/examples/webpage_to_markdown.py → chatterer-0.1.24/chatterer/examples/web2md.py

@@ -1,13 +1,13 @@
 from pathlib import Path
 from typing import Literal
 
-from spargear import ArgumentSpec, BaseArguments
+from spargear import ArgumentSpec, RunnableArguments
 
 from chatterer import Chatterer, MarkdownLink, PlayWrightBot
 
 
-class WebpageToMarkdownArgs(BaseArguments):
-    url: str
+class Arguments(RunnableArguments[None]):
+    URL: str
     """The URL to crawl."""
     output: str = Path(__file__).with_suffix(".md").as_posix()
     """The output file path for the markdown file."""
@@ -21,7 +21,7 @@ class WebpageToMarkdownArgs(BaseArguments):
 
     def run(self) -> None:
         chatterer = self.chatterer.value
-        url: str = self.url.strip()
+        url: str = self.URL.strip()
         output: Path = Path(self.output).resolve()
         with PlayWrightBot(chatterer=chatterer, engine=self.engine) as bot:
             md = bot.url_to_md(url)
@@ -32,15 +32,13 @@ class WebpageToMarkdownArgs(BaseArguments):
             links = MarkdownLink.from_markdown(md, referer_url=url)
             for link in links:
                 if link.type == "link":
-                    print(
-                        f"- [{truncate_string(link.url)}] {truncate_string(link.inline_text)} ({truncate_string(link.inline_title)})"
-                    )
+                    print(f"- [{truncate_string(link.url)}] {truncate_string(link.inline_text)} ({truncate_string(link.inline_title)})")
                 elif link.type == "image":
                     print(f"- ![{truncate_string(link.url)}] ({truncate_string(link.inline_text)})")
 
     async def arun(self) -> None:
         chatterer = self.chatterer.value
-        url: str = self.url.strip()
+        url: str = self.URL.strip()
         output: Path = Path(self.output).resolve()
         async with PlayWrightBot(chatterer=chatterer, engine=self.engine) as bot:
             md = await bot.aurl_to_md(url)
@@ -51,9 +49,7 @@ class WebpageToMarkdownArgs(BaseArguments):
             links = MarkdownLink.from_markdown(md, referer_url=url)
             for link in links:
                 if link.type == "link":
-                    print(
-                        f"- [{truncate_string(link.url)}] {truncate_string(link.inline_text)} ({truncate_string(link.inline_title)})"
-                    )
+                    print(f"- [{truncate_string(link.url)}] {truncate_string(link.inline_text)} ({truncate_string(link.inline_title)})")
                 elif link.type == "image":
                     print(f"- ![{truncate_string(link.url)}] ({truncate_string(link.inline_text)})")
 
@@ -63,7 +59,7 @@ def truncate_string(s: str) -> str:
 
 
 def main() -> None:
-    WebpageToMarkdownArgs().run()
+    Arguments().run()
 
 
 if __name__ == "__main__":