chatterer 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

chatterer/examples/login_with_playwright.py

@@ -1,156 +0,0 @@
-import json
-import logging
-import sys
-from pathlib import Path
-
-from spargear import BaseArguments, 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(BaseArguments):
-    """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."""
-
-
-class WriteArgs(BaseArguments):
-    """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."""
-
-
-class LoginWithPlaywrightArgs(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."""
-        try:
-            if (read := self.read.argument_class).url:
-                # Access attributes directly from the returned instance
-                logger.info("Running READ command:")
-                logger.info(f"    URL: {read.url}")
-                logger.info(f"    JSON Path: {read.jsonpath}")
-                read_session(url=read.url, jsonpath=read.jsonpath)
-            elif (write := self.write.argument_class).url:
-                # Access attributes directly from the returned instance
-                logger.info("Running WRITE command:")
-                logger.info(f"    URL: {write.url}")
-                logger.info(f"    JSON Path: {write.jsonpath}")
-                write_session(url=write.url, jsonpath=write.jsonpath)
-            else:
-                logger.error("No valid subcommand provided. Use 'read' or 'write'.")
-                sys.exit(1)
-
-        except SystemExit as e:
-            # Handle cases like -h/--help or argparse errors that exit
-            sys.exit(e.code)
-        except Exception as e:
-            logger.error(f"\nAn error occurred: {e}")
-            # from traceback import print_exc # Uncomment for full traceback
-            # print_exc()                   # Uncomment for full traceback
-            sys.exit(1)
-
-
-def read_session(url: str, jsonpath: Path) -> 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.
-    """
-    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.")
-
-
-def write_session(url: str, jsonpath: Path) -> 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.
-    """
-    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.")
-
-
-def main() -> None:
-    LoginWithPlaywrightArgs().run()
-
-
-if __name__ == "__main__":
-    main()

chatterer/examples/pdf_to_markdown.py

@@ -1,77 +0,0 @@
-import logging
-import sys
-from pathlib import Path
-from typing import Optional
-
-from spargear import ArgumentSpec, BaseArguments
-
-from chatterer import Chatterer, PdfToMarkdown
-
-logger = logging.getLogger(__name__)
-
-
-class PdfToMarkdownArgs(BaseArguments):
-    input: str
-    """Input PDF file or directory containing PDF files to convert to markdown."""
-    output: Optional[str] = None
-    """Output path. For a file, path to the output markdown file. For a directory, output directory for .md files."""
-    """Chatterer instance for communication."""
-    page: Optional[str] = None
-    """Zero-based page indices to convert (e.g., '0,2,4-8')."""
-    recursive: bool = False
-    """If input is a directory, search for PDFs recursively."""
-    chatterer: ArgumentSpec[Chatterer] = ArgumentSpec(
-        ["--chatterer"],
-        default_factory=lambda: Chatterer.from_provider("google:gemini-2.5-flash-preview-05-20"),
-        help="Chatterer instance for communication.",
-        type=Chatterer.from_provider,
-    )
-
-    def run(self) -> list[dict[str, str]]:
-        input = Path(self.input).resolve()
-        pdf_files: list[Path] = []
-        is_dir = False
-        if input.is_file():
-            if input.suffix.lower() != ".pdf":
-                sys.exit(1)
-            pdf_files.append(input)
-        elif input.is_dir():
-            is_dir = True
-            pattern = "*.pdf"
-            pdf_files = sorted([
-                f for f in (input.rglob(pattern) if self.recursive else input.glob(pattern)) if f.is_file()
-            ])
-            if not pdf_files:
-                sys.exit(0)
-        else:
-            sys.exit(1)
-        if self.output:
-            out_base = Path(self.output).resolve()
-        elif is_dir:
-            out_base = input
-        else:
-            out_base = input.with_suffix(".md")
-
-        if is_dir:
-            out_base.mkdir(parents=True, exist_ok=True)
-        else:
-            out_base.parent.mkdir(parents=True, exist_ok=True)
-
-        converter = PdfToMarkdown(chatterer=self.chatterer.unwrap())
-        results: list[dict[str, str]] = []
-        for pdf in pdf_files:
-            output: Path = (out_base / (pdf.stem + ".md")) if is_dir else out_base
-            md: str = converter.convert(pdf_input=str(pdf), page_indices=self.page)
-            output.parent.mkdir(parents=True, exist_ok=True)
-            output.write_text(md, encoding="utf-8")
-            results.append({"input": pdf.as_posix(), "output": output.as_posix(), "result": md})
-        logger.info(f"Converted {len(pdf_files)} PDF(s) to markdown and saved to `{out_base}`.")
-        return results
-
-
-def main() -> None:
-    PdfToMarkdownArgs().run()
-
-
-if __name__ == "__main__":
-    main()

chatterer-0.1.22.dist-info/entry_points.txt

@@ -1,10 +0,0 @@
-[console_scripts]
-anything-to-markdown = chatterer.examples.anything_to_markdown:main
-get-code-snippets = chatterer.examples.get_code_snippets:main
-login-with-playwright = chatterer.examples.login_with_playwright:main
-make-ppt = chatterer.examples.make_ppt:main
-pdf-to-markdown = chatterer.examples.pdf_to_markdown:main
-pdf-to-text = chatterer.examples.pdf_to_text:main
-transcription-api = chatterer.examples.transcription_api:main
-upstage-parser = chatterer.examples.upstage_parser:main
-webpage-to-markdown = chatterer.examples.webpage_to_markdown:main