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

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/examples/{anything_to_markdown.py → 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/examples/{pdf_to_markdown.py → 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/examples/{pdf_to_text.py → 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/examples/{make_ppt.py → 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/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/examples/{get_code_snippets.py → 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/examples/{transcription_api.py → 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/examples/{upstage_parser.py → 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/examples/{webpage_to_markdown.py → 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__":

chatterer/strategies/atom_of_thoughts.py

@@ -781,143 +781,143 @@ class AoTPipeline:
     # 4.6) Build or export a reasoning graph
     # ---------------------------------------------------------------------------------
 
-    def get_reasoning_graph(self, global_id_prefix: str = "AoT"):
-        """
-        Constructs a Graph object (from hypothetical `neo4j_extension`)
-        capturing the pipeline steps, including devil's advocate steps.
-        """
-        from neo4j_extension import Graph, Node, Relationship
-
-        g = Graph()
-        step_nodes: dict[int, Node] = {}
-        subq_nodes: dict[str, Node] = {}
-
-        # Step A: Create nodes for each pipeline step
-        for i, record in enumerate(self.steps_history):
-            # We'll skip nested Decomposition steps only if we want to flatten them.
-            # But let's keep them for clarity.
-            step_node = Node(
-                properties=record.as_properties(), labels={record.step_name}, globalId=f"{global_id_prefix}_step_{i}"
-            )
-            g.add_node(step_node)
-            step_nodes[i] = step_node
-
-        # Step B: Collect sub-questions from each DECOMPOSITION or DEVILS_ADVOCATE
-        all_sub_questions: dict[str, tuple[int, int, SubQuestionNode]] = {}
-        for i, record in enumerate(self.steps_history):
-            if record.sub_questions:
-                for sq_idx, sq in enumerate(record.sub_questions):
-                    sq_id = f"{global_id_prefix}_decomp_{i}_sub_{sq_idx}"
-                    all_sub_questions[sq_id] = (i, sq_idx, sq)
-
-        for sq_id, (i, sq_idx, sq) in all_sub_questions.items():
-            n_subq = Node(
-                properties={
-                    "question": sq.question,
-                    "answer": sq.answer or "",
-                },
-                labels={"SubQuestion"},
-                globalId=sq_id,
-            )
-            g.add_node(n_subq)
-            subq_nodes[sq_id] = n_subq
-
-        # Step C: Add relationships. We do a simple approach:
-        #  - If StepRecord is DECOMPOSITION or DEVILS_ADVOCATE with sub_questions, link them via SPLIT_INTO.
-        for i, record in enumerate(self.steps_history):
-            if record.sub_questions:
-                start_node = step_nodes[i]
-                for sq_idx, sq in enumerate(record.sub_questions):
-                    sq_id = f"{global_id_prefix}_decomp_{i}_sub_{sq_idx}"
-                    end_node = subq_nodes[sq_id]
-                    rel = Relationship(
-                        properties={},
-                        rel_type=StepRelation.SPLIT_INTO,
-                        start_node=start_node,
-                        end_node=end_node,
-                        globalId=f"{global_id_prefix}_split_{i}_{sq_idx}",
-                    )
-                    g.add_relationship(rel)
-                    # Also add sub-question dependencies
-                    for dep in sq.depend:
-                        # The same record i -> sub-question subq
-                        if 0 <= dep < len(record.sub_questions):
-                            dep_id = f"{global_id_prefix}_decomp_{i}_sub_{dep}"
-                            if dep_id in subq_nodes:
-                                dep_node = subq_nodes[dep_id]
-                                rel_dep = Relationship(
-                                    properties={},
-                                    rel_type=StepRelation.DEPEND_ON,
-                                    start_node=end_node,
-                                    end_node=dep_node,
-                                    globalId=f"{global_id_prefix}_dep_{i}_q_{sq_idx}_on_{dep}",
-                                )
-                                g.add_relationship(rel_dep)
-
-        # Step D: We add PRECEDES relationships in a linear chain for the pipeline steps
-        for i in range(len(self.steps_history) - 1):
-            start_node = step_nodes[i]
-            end_node = step_nodes[i + 1]
-            rel = Relationship(
-                properties={},
-                rel_type=StepRelation.PRECEDES,
-                start_node=start_node,
-                end_node=end_node,
-                globalId=f"{global_id_prefix}_precede_{i}_to_{i + 1}",
-            )
-            g.add_relationship(rel)
-
-        # Step E: CRITIQUES, SELECTS, RESULT_OF can be similarly added:
-        # We'll do a simple pass:
-        # If step_name ends with CRITIQUE => it critiques the step before it
-        for i, record in enumerate(self.steps_history):
-            if "CRITIQUE" in record.step_name:
-                # Let it point to the preceding step
-                if i > 0:
-                    start_node = step_nodes[i]
-                    end_node = step_nodes[i - 1]
-                    rel = Relationship(
-                        properties={},
-                        rel_type=StepRelation.CRITIQUES,
-                        start_node=start_node,
-                        end_node=end_node,
-                        globalId=f"{global_id_prefix}_crit_{i}",
-                    )
-                    g.add_relationship(rel)
-
-        # If there's a BEST_APPROACH_DECISION step, link it to the step it uses
-        best_decision_idx = None
-        used_step_idx = None
-        for i, record in enumerate(self.steps_history):
-            if record.step_name == StepName.BEST_APPROACH_DECISION and record.used:
-                best_decision_idx = i
-                # find the step with that name
-                used_step_idx = next((j for j in step_nodes if self.steps_history[j].step_name == record.used), None)
-                if used_step_idx is not None:
-                    rel = Relationship(
-                        properties={},
-                        rel_type=StepRelation.SELECTS,
-                        start_node=step_nodes[i],
-                        end_node=step_nodes[used_step_idx],
-                        globalId=f"{global_id_prefix}_select_{i}_use_{used_step_idx}",
-                    )
-                    g.add_relationship(rel)
-
-        # And link the final answer to the best approach
-        final_answer_idx = next(
-            (i for i, r in enumerate(self.steps_history) if r.step_name == StepName.FINAL_ANSWER), None
-        )
-        if final_answer_idx is not None and best_decision_idx is not None:
-            rel = Relationship(
-                properties={},
-                rel_type=StepRelation.RESULT_OF,
-                start_node=step_nodes[final_answer_idx],
-                end_node=step_nodes[best_decision_idx],
-                globalId=f"{global_id_prefix}_final_{final_answer_idx}_resultof_{best_decision_idx}",
-            )
-            g.add_relationship(rel)
-
-        return g
+    # def get_reasoning_graph(self, global_id_prefix: str = "AoT"):
+    #     """
+    #     Constructs a Graph object (from hypothetical `neo4j_extension`)
+    #     capturing the pipeline steps, including devil's advocate steps.
+    #     """
+    #     from neo4j_extension import Graph, Node, Relationship
+
+    #     g = Graph()
+    #     step_nodes: dict[int, Node] = {}
+    #     subq_nodes: dict[str, Node] = {}
+
+    #     # Step A: Create nodes for each pipeline step
+    #     for i, record in enumerate(self.steps_history):
+    #         # We'll skip nested Decomposition steps only if we want to flatten them.
+    #         # But let's keep them for clarity.
+    #         step_node = Node(
+    #             properties=record.as_properties(), labels={record.step_name}, globalId=f"{global_id_prefix}_step_{i}"
+    #         )
+    #         g.add_node(step_node)
+    #         step_nodes[i] = step_node
+
+    #     # Step B: Collect sub-questions from each DECOMPOSITION or DEVILS_ADVOCATE
+    #     all_sub_questions: dict[str, tuple[int, int, SubQuestionNode]] = {}
+    #     for i, record in enumerate(self.steps_history):
+    #         if record.sub_questions:
+    #             for sq_idx, sq in enumerate(record.sub_questions):
+    #                 sq_id = f"{global_id_prefix}_decomp_{i}_sub_{sq_idx}"
+    #                 all_sub_questions[sq_id] = (i, sq_idx, sq)
+
+    #     for sq_id, (i, sq_idx, sq) in all_sub_questions.items():
+    #         n_subq = Node(
+    #             properties={
+    #                 "question": sq.question,
+    #                 "answer": sq.answer or "",
+    #             },
+    #             labels={"SubQuestion"},
+    #             globalId=sq_id,
+    #         )
+    #         g.add_node(n_subq)
+    #         subq_nodes[sq_id] = n_subq
+
+    #     # Step C: Add relationships. We do a simple approach:
+    #     #  - If StepRecord is DECOMPOSITION or DEVILS_ADVOCATE with sub_questions, link them via SPLIT_INTO.
+    #     for i, record in enumerate(self.steps_history):
+    #         if record.sub_questions:
+    #             start_node = step_nodes[i]
+    #             for sq_idx, sq in enumerate(record.sub_questions):
+    #                 sq_id = f"{global_id_prefix}_decomp_{i}_sub_{sq_idx}"
+    #                 end_node = subq_nodes[sq_id]
+    #                 rel = Relationship(
+    #                     properties={},
+    #                     rel_type=StepRelation.SPLIT_INTO,
+    #                     start_node=start_node,
+    #                     end_node=end_node,
+    #                     globalId=f"{global_id_prefix}_split_{i}_{sq_idx}",
+    #                 )
+    #                 g.add_relationship(rel)
+    #                 # Also add sub-question dependencies
+    #                 for dep in sq.depend:
+    #                     # The same record i -> sub-question subq
+    #                     if 0 <= dep < len(record.sub_questions):
+    #                         dep_id = f"{global_id_prefix}_decomp_{i}_sub_{dep}"
+    #                         if dep_id in subq_nodes:
+    #                             dep_node = subq_nodes[dep_id]
+    #                             rel_dep = Relationship(
+    #                                 properties={},
+    #                                 rel_type=StepRelation.DEPEND_ON,
+    #                                 start_node=end_node,
+    #                                 end_node=dep_node,
+    #                                 globalId=f"{global_id_prefix}_dep_{i}_q_{sq_idx}_on_{dep}",
+    #                             )
+    #                             g.add_relationship(rel_dep)
+
+    #     # Step D: We add PRECEDES relationships in a linear chain for the pipeline steps
+    #     for i in range(len(self.steps_history) - 1):
+    #         start_node = step_nodes[i]
+    #         end_node = step_nodes[i + 1]
+    #         rel = Relationship(
+    #             properties={},
+    #             rel_type=StepRelation.PRECEDES,
+    #             start_node=start_node,
+    #             end_node=end_node,
+    #             globalId=f"{global_id_prefix}_precede_{i}_to_{i + 1}",
+    #         )
+    #         g.add_relationship(rel)
+
+    #     # Step E: CRITIQUES, SELECTS, RESULT_OF can be similarly added:
+    #     # We'll do a simple pass:
+    #     # If step_name ends with CRITIQUE => it critiques the step before it
+    #     for i, record in enumerate(self.steps_history):
+    #         if "CRITIQUE" in record.step_name:
+    #             # Let it point to the preceding step
+    #             if i > 0:
+    #                 start_node = step_nodes[i]
+    #                 end_node = step_nodes[i - 1]
+    #                 rel = Relationship(
+    #                     properties={},
+    #                     rel_type=StepRelation.CRITIQUES,
+    #                     start_node=start_node,
+    #                     end_node=end_node,
+    #                     globalId=f"{global_id_prefix}_crit_{i}",
+    #                 )
+    #                 g.add_relationship(rel)
+
+    #     # If there's a BEST_APPROACH_DECISION step, link it to the step it uses
+    #     best_decision_idx = None
+    #     used_step_idx = None
+    #     for i, record in enumerate(self.steps_history):
+    #         if record.step_name == StepName.BEST_APPROACH_DECISION and record.used:
+    #             best_decision_idx = i
+    #             # find the step with that name
+    #             used_step_idx = next((j for j in step_nodes if self.steps_history[j].step_name == record.used), None)
+    #             if used_step_idx is not None:
+    #                 rel = Relationship(
+    #                     properties={},
+    #                     rel_type=StepRelation.SELECTS,
+    #                     start_node=step_nodes[i],
+    #                     end_node=step_nodes[used_step_idx],
+    #                     globalId=f"{global_id_prefix}_select_{i}_use_{used_step_idx}",
+    #                 )
+    #                 g.add_relationship(rel)
+
+    #     # And link the final answer to the best approach
+    #     final_answer_idx = next(
+    #         (i for i, r in enumerate(self.steps_history) if r.step_name == StepName.FINAL_ANSWER), None
+    #     )
+    #     if final_answer_idx is not None and best_decision_idx is not None:
+    #         rel = Relationship(
+    #             properties={},
+    #             rel_type=StepRelation.RESULT_OF,
+    #             start_node=step_nodes[final_answer_idx],
+    #             end_node=step_nodes[best_decision_idx],
+    #             globalId=f"{global_id_prefix}_final_{final_answer_idx}_resultof_{best_decision_idx}",
+    #         )
+    #         g.add_relationship(rel)
+
+    #     return g
 
 
 # ---------------------------------------------------------------------------------
@@ -944,32 +944,32 @@ class AoTStrategy(BaseStrategy):
         msgs = self.pipeline.chatterer.client._convert_input(messages).to_messages()  # type: ignore
         return self.pipeline.run_pipeline(msgs)
 
-    def get_reasoning_graph(self):
-        """Return the AoT reasoning graph from the pipeline’s steps history."""
-        return self.pipeline.get_reasoning_graph(global_id_prefix="AoT")
+    # def get_reasoning_graph(self):
+    #     """Return the AoT reasoning graph from the pipeline’s steps history."""
+    #     return self.pipeline.get_reasoning_graph(global_id_prefix="AoT")
 
 
 # ---------------------------------------------------------------------------------
 # Example usage (pseudo-code)
 # ---------------------------------------------------------------------------------
-if __name__ == "__main__":
-    from neo4j_extension import Neo4jConnection  # or your actual DB connector
-
-    # You would create a Chatterer with your chosen LLM backend (OpenAI, etc.)
-    chatterer = Chatterer.openai()  # pseudo-code
-    pipeline = AoTPipeline(chatterer=chatterer, max_depth=3)
-    strategy = AoTStrategy(pipeline=pipeline)
-
-    question = "Solve 5.9 = 5.11 - x. Also compare 9.11 and 9.9."
-    answer = strategy.invoke(question)
-    print("Final Answer:", answer)
-
-    # Build the reasoning graph
-    graph = strategy.get_reasoning_graph()
-    print(f"\nGraph has {len(graph.nodes)} nodes and {len(graph.relationships)} relationships.")
-
-    # Optionally store in Neo4j
-    with Neo4jConnection() as conn:
-        conn.clear_all()
-        conn.upsert_graph(graph)
-        print("Graph stored in Neo4j.")
+# if __name__ == "__main__":
+#     from neo4j_extension import Neo4jConnection  # or your actual DB connector
+
+#     # You would create a Chatterer with your chosen LLM backend (OpenAI, etc.)
+#     chatterer = Chatterer.openai()  # pseudo-code
+#     pipeline = AoTPipeline(chatterer=chatterer, max_depth=3)
+#     strategy = AoTStrategy(pipeline=pipeline)
+
+#     question = "Solve 5.9 = 5.11 - x. Also compare 9.11 and 9.9."
+#     answer = strategy.invoke(question)
+#     print("Final Answer:", answer)
+
+#     # Build the reasoning graph
+#     graph = strategy.get_reasoning_graph()
+#     print(f"\nGraph has {len(graph.nodes)} nodes and {len(graph.relationships)} relationships.")
+
+#     # Optionally store in Neo4j
+#     with Neo4jConnection() as conn:
+#         conn.clear_all()
+#         conn.upsert_graph(graph)
+#         print("Graph stored in Neo4j.")

{chatterer-0.1.23.dist-info → chatterer-0.1.24.dist-info}/METADATA

@@ -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.23.dist-info → chatterer-0.1.24.dist-info}/RECORD

@@ -6,17 +6,18 @@ 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/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chatterer/examples/anything_to_markdown.py,sha256=4O9ze7AIHcwEzvVmm5JMMKo_rVSFwhPL8MVHtfMLJ5Y,2734
-chatterer/examples/get_code_snippets.py,sha256=pz05JjhKaWAknVKlk1ftEEzpSG4-sqD9oa_gyIQoCAs,1911
-chatterer/examples/login_with_playwright.py,sha256=EhvJLaH5TD7bmDi12uP8YLd0fRhdjR-oyIkBHLi1Jjs,5988
-chatterer/examples/make_ppt.py,sha256=vsT_iL_jS2ami5VYrReLMQcD576FfZUH7913F7_As0A,23278
-chatterer/examples/pdf_to_markdown.py,sha256=mur63PxI0uwl90Mh49VXPuO0YSwyEfs0-MwxJWKWXec,13577
-chatterer/examples/pdf_to_text.py,sha256=DznTyhu1REv8Wp4RimQWVgEU5j0_BmlwjfJYJvx3dbI,1590
-chatterer/examples/transcription_api.py,sha256=WUs12qHH4616eLMQDHOiyVGxaXstTpgeE47djYyli6c,3897
-chatterer/examples/upstage_parser.py,sha256=TrfeSIiF0xklhFCknop22TIOVibI4CJ_UKj5-lD8c8E,3487
-chatterer/examples/webpage_to_markdown.py,sha256=DnZfQ-trXBiOiszA2tMlgadgKH-ObTi6l4gGloT-cQw,2846
+chatterer/examples/__main__.py,sha256=W-Zo7z9RyA0PrY-tPDqf9BSkOqPpaIXROcHCXCwNXc4,1566
+chatterer/examples/any2md.py,sha256=4AtdlwP1jxSsvh31yWmB5HP2Wmof4Fh0W_F3im2yJ_M,2739
+chatterer/examples/pdf2md.py,sha256=viru-9vrUdiYMXRpQVpbYiZy6bjkkF-HTXSvy37ICUY,13625
+chatterer/examples/pdf2txt.py,sha256=ULfA2cr-lrfLVqpMlSa08qo5AXVXiyL8N2-KiD0Orhc,1602
+chatterer/examples/ppt.py,sha256=7AhS2hZtmMHOJQt1j5DQDDgrMwM-GX1HjPrmKDV2Bgs,23253
+chatterer/examples/pw.py,sha256=FGmCQg5XFyVAczBF8mQcobJcvITKEOtbrXm4pyKvbAw,5138
+chatterer/examples/snippet.py,sha256=JvR_xBV8skePCtIczz73EdjmiHzj_A-5HzS53j0bLI4,1973
+chatterer/examples/transcribe.py,sha256=fBFuo442VEM7NbF9xN3ub3nAnYnQojrseN_kI049fsM,3894
+chatterer/examples/upstage.py,sha256=lK2OOY6U4GGnDBbPHKaqwlh_0Vu-0RMb0M01M8dngRs,3219
+chatterer/examples/web2md.py,sha256=zfemaE3KwfU8LHvWzJHX-knASpikBUUNzv6jTmfac1E,2740
 chatterer/strategies/__init__.py,sha256=SdOggbmHpw4f7Njwy-T8q64e91OLOUp1k0a0ozZd4qI,221
-chatterer/strategies/atom_of_thoughts.py,sha256=pUhqt47YlzBIVNRh0UebeBwuJ0J94Ge6yZgXxrsiDPE,40884
+chatterer/strategies/atom_of_thoughts.py,sha256=30XvnVKjty8Geo2z_n2-RWL_eEvo_AnK8sg8uVPQHOQ,41178
 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
@@ -37,8 +38,8 @@ chatterer/utils/base64_image.py,sha256=m_qAT3ERBiq8D-H4H9Z7rLfL31_BiPmV_m4uQ5XRL
 chatterer/utils/bytesio.py,sha256=3MC2atOOFKo5YxuReo_y_t8Wem9p2Y1ahC5M2lGclwI,2618
 chatterer/utils/code_agent.py,sha256=7ka_WRI4TQmZ5H46mjY3hI6RO_pxw6pg3LAxjgW4AbM,10495
 chatterer/utils/imghdr.py,sha256=6JhJMXD4MZ0dQolT2VM87YrRYm3hPf3RTEWnP4lYRVc,3842
-chatterer-0.1.23.dist-info/METADATA,sha256=zCTgA4OAI2tSpNRiLwjCDPweTrW4oxzJnIXT7PA69Ck,11826
-chatterer-0.1.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chatterer-0.1.23.dist-info/entry_points.txt,sha256=KhxL2dctnZalnDSmPoB5dZBBa9hZpJETW3C5xkoRaW4,554
-chatterer-0.1.23.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
-chatterer-0.1.23.dist-info/RECORD,,
+chatterer-0.1.24.dist-info/METADATA,sha256=mpTNGDkwWEK-9XdP52DGaVKQphtJ_p6Wmibq-eiq07g,11633
+chatterer-0.1.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chatterer-0.1.24.dist-info/entry_points.txt,sha256=IzGKhTnZ7G5V23SRmulmSsyt9HcaFH4lU4r3wR1zMsc,63
+chatterer-0.1.24.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
+chatterer-0.1.24.dist-info/RECORD,,

chatterer-0.1.24.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chatterer = chatterer.examples.__main__:main

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-0.1.23.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