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

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.")