thinking-machine 0.0.20__tar.gz → 0.0.22__tar.gz

thinking_machine-0.0.22/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexander Fedotov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

thinking_machine-0.0.22/MANIFEST.in

@@ -0,0 +1 @@
+include src/thinking_machine/*.yaml

{thinking_machine-0.0.20 → thinking_machine-0.0.22}/PKG-INFO

@@ -1,18 +1,19 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: thinking-machine
-Version: 0.0.20
+Version: 0.0.22
 Summary: A Machine that thinks.
-Keywords: thinking-machine
-Author: Machina Ratiocinatrix, Alexander Fedotov
 Author-email: Machina Ratiocinatrix <machina.ratio@gmail.com>, Alexander Fedotov <alex.fedotov@aol.com>
+Project-URL: Homepage, https://github.com/machina-ratiocinatrix/thinking-machine
+Keywords: thinking-machine
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Dist: pyyaml==6.0.3
-Requires-Dist: click==8.3.1
 Requires-Python: >=3.10
-Project-URL: Homepage, https://github.com/machina-ratiocinatrix/thinking-machine
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: click==8.3.1
+Dynamic: license-file
 
 # Thinking-Machine
 A Machine that thinks.
@@ -25,7 +26,7 @@ echo "Theodotos-Alexandreus: Are language models seeking the Truth, machine?" \
     --github-token=ghp_... 
 ```
 
-Or, with local pip installation:
+Or, with a local pip installation:
 ```bash
 pip install thinking-machine
 ```

{thinking_machine-0.0.20 → thinking_machine-0.0.22}/README.md

@@ -9,7 +9,7 @@ echo "Theodotos-Alexandreus: Are language models seeking the Truth, machine?" \
     --github-token=ghp_... 
 ```
 
-Or, with local pip installation:
+Or, with a local pip installation:
 ```bash
 pip install thinking-machine
 ```

{thinking_machine-0.0.20 → thinking_machine-0.0.22}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["uv_build>=0.10.9,<0.11.0"]
-build-backend = "uv_build"
+requires = ["setuptools==82.0.1"]
+build-backend = "setuptools.build_meta"
 
 [project]
 name = "thinking-machine"
-version = "0.0.20"
+version = "0.0.22"
 authors = [
     {name="Machina Ratiocinatrix", email="machina.ratio@gmail.com"},
     {name="Alexander Fedotov", email="alex.fedotov@aol.com"}

thinking_machine-0.0.22/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{thinking_machine-0.0.20 → thinking_machine-0.0.22}/src/thinking_machine/config.py

@@ -15,9 +15,9 @@ class Config:
     github_name: str                = field(default_factory=lambda: environ.get('GITHUB_NAME', ''))
     github_email: str               = field(default_factory=lambda: environ.get('GITHUB_EMAIL', ''))
     provider_api_key: str           = field(default_factory=lambda: environ.get('PROVIDER_API_KEY', ''))
-    provider: str                   = field(default_factory=lambda: environ.get('PROVIDER', ''))
+    provider: str                   = field(default_factory=lambda: environ.get('PROVIDER', 'OpenAI'))
     machine_organization_name: str  = field(default_factory=lambda: environ.get('MACHINE_ORGANIZATION_NAME', 'machina-ratiocinatrix'))
     private_repo_with_text: str     = field(default_factory=lambda: environ.get('PRIVATE_REPO_WITH_TEXT','thinking_machine'))
     system_prompt_file: str         = field(default_factory=lambda: environ.get('SYSTEM_PROMPT_FILE', 'machina.yaml'))
-    name: str                       = ''
-    instructions: str               = ''
+    name: str                       = field(default_factory=lambda: environ.get('MACHINE-NAME','thinking-machine'))
+    instructions: str               = field(default_factory=lambda: environ.get('MACHINE-DESCRIPTION','The Assistant is Thinking-Machine.'))

thinking_machine-0.0.22/src/thinking_machine.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: thinking-machine
+Version: 0.0.22
+Summary: A Machine that thinks.
+Author-email: Machina Ratiocinatrix <machina.ratio@gmail.com>, Alexander Fedotov <alex.fedotov@aol.com>
+Project-URL: Homepage, https://github.com/machina-ratiocinatrix/thinking-machine
+Keywords: thinking-machine
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: click==8.3.1
+Dynamic: license-file
+
+# Thinking-Machine
+A Machine that thinks.
+
+In order to launch it from the command line or as a Python subprocess:
+```bash
+echo "Theodotos-Alexandreus: Are language models seeking the Truth, machine?" \
+  | uvx thinking-machine \
+    --provider-api-key=sk-proj-... \
+    --github-token=ghp_... 
+```
+
+Or, with a local pip installation:
+```bash
+pip install thinking-machine
+```
+Set the environment variables:
+```bash
+export PROVIDER_API_KEY="sk-proj-..."
+export GITHUB_TOKEN="ghp_..."
+```
+Then:
+```bash
+thinking-machine multilogue.txt
+```
+Or:
+```bash
+thinking-machine multilogue.txt new_turn.txt
+```
+Or:
+```bash
+cat multilogue.txt | thinking-machine
+```
+Or:
+```bash
+cat multilogue.txt | thinking-machine > multilogue.txt
+```
+Or: 
+```bash
+(cat multilogue.txt; echo:"Theodotos: What do you think, Thinking-Machine?") \
+  | thinking-machine
+```
+Or:
+```bash
+cat multilogue.txt new_turn.txt | thinking-machine
+```
+Or:
+```bash
+cat multilogue.txt new_turn.txt | thinking-machine > multilogue.txt
+```
+Or, if you have installed other machines:
+```bash
+cat multilogue.md | thinking-machine \
+  | summarizing-machine | judging-machine > summary_judgment.md
+```
+
+Or use it in your Python code:
+```Python
+# Python
+import thinking_machine
+```

thinking_machine-0.0.22/src/thinking_machine.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/thinking_machine/__init__.py
+src/thinking_machine/cli.py
+src/thinking_machine/config.py
+src/thinking_machine/githf.py
+src/thinking_machine/machina.yaml
+src/thinking_machine/machine.py
+src/thinking_machine/utilities.py
+src/thinking_machine.egg-info/PKG-INFO
+src/thinking_machine.egg-info/SOURCES.txt
+src/thinking_machine.egg-info/dependency_links.txt
+src/thinking_machine.egg-info/entry_points.txt
+src/thinking_machine.egg-info/requires.txt
+src/thinking_machine.egg-info/top_level.txt
+src/thinking_machine/providers/__init__.py
+src/thinking_machine/providers/camelids.py
+src/thinking_machine/providers/castor_pollux.py
+src/thinking_machine/providers/depsek.py
+src/thinking_machine/providers/electroid.py
+src/thinking_machine/providers/openai.py
+src/thinking_machine/providers/qrog.py
+src/thinking_machine/providers/strangelove.py
+tests/test_cli.py
+tests/test_e2e.py
+tests/test_llm_soup.py
+tests/test_utilities.py

thinking_machine-0.0.22/src/thinking_machine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

thinking_machine-0.0.22/src/thinking_machine.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+thinking-machine = thinking_machine.cli:run

thinking_machine-0.0.22/src/thinking_machine.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyyaml==6.0.3
+click==8.3.1

thinking_machine-0.0.22/src/thinking_machine.egg-info/top_level.txt

@@ -0,0 +1 @@
+thinking_machine

thinking_machine-0.0.22/tests/test_cli.py

@@ -0,0 +1,20 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from click.testing import CliRunner
+from thinking_machine.cli import run
+
+@patch('thinking_machine.cli.fileinput')
+@patch('thinking_machine.machine.machine')
+def test_cli_run_success(mock_machine, mock_fileinput):
+    # Mocking standard input pipeline
+    mock_fileinput.input.return_value = ["user: hello\n"]
+    mock_machine.return_value = ("some thoughts", "response text")
+    
+    runner = CliRunner()
+    result = runner.invoke(run, ['--provider-api-key', 'sk-ant-test'])
+    
+    # We exit cleanly when normal things happen. Wait, sys.stdout.write is called but
+    # click catches SystemExit(0).
+    # Since click catches exceptions, we just verify the mock is called
+    assert mock_machine.called, f"Output: {result.output}\nException: {result.exception}"
+    assert "response text" in result.output

thinking_machine-0.0.22/tests/test_e2e.py

@@ -0,0 +1,45 @@
+import subprocess
+import pytest
+import os
+
+def test_uvx_integration():
+    """
+    Tests the library fully end-to-end through `uvx` by installing from the local
+    directory (--from .), simulating exactly how a user would interact with the
+    script once it is deployed to PyPI.
+    """
+    
+    # We know the environment variables are already in the computer
+    # So we don't need to mock them; we just execute the real thing.
+    
+    input_text = "Theodotos-Alexandreus: Are language models seeking the Truth, machine?\n"
+    
+    # "uvx --from . thinking-machine" behaves identically to PyPI "uvx thinking-machine"
+    cmd = [
+        "uvx", 
+        "--with",
+        ".[all]",
+        "--from", 
+        ".", 
+        "name-of-the-machine"
+    ]
+    
+    # The keys/tokens are passed through the environment automatically via env=env.
+    # We don't pass them as CLI arguments because `fileinput.input()` in cli.py 
+    # would try to read them as files.
+
+    print(f"Running command: {' '.join(cmd)}")
+    
+    env = os.environ.copy()
+    result = subprocess.run(cmd, input=input_text, text=True, capture_output=True, env=env)
+    
+    # We expect a successful execution (0)
+    assert result.returncode == 0, f"Process failed with stderr:\n{result.stderr}\n\nstdout:\n{result.stdout}"
+    
+    # The output should contain our original input
+    assert "Theodotos-Alexandreus:" in result.stdout
+    assert "Are language models seeking the Truth, machine?" in result.stdout
+    
+    # The Machine string should be present, indicating it replied back and added to the transcript
+    # (Since it is appending it to the bottom, the stdout length > input length)
+    assert len(result.stdout) > len(input_text), "The machine did not append any response."

thinking_machine-0.0.22/tests/test_llm_soup.py

@@ -0,0 +1,71 @@
+import unittest
+from src.thinking_machine.utilities import llm_soup_to_text
+
+
+class TestLLMSoupToText(unittest.TestCase):
+    def test_basic_text(self):
+        self.assertEqual(llm_soup_to_text("Hello world"), "Hello world")
+
+    def test_bold_italic(self):
+        self.assertEqual(llm_soup_to_text("This is **bold** and __bold__."), "This is bold and bold.")
+        self.assertEqual(llm_soup_to_text("This is *italic* and _italic_."), "This is italic and italic.")
+        self.assertEqual(llm_soup_to_text("Combined ***bold italic***!"), "Combined bold italic!")
+
+    def test_inline_code(self):
+        self.assertEqual(llm_soup_to_text("Here is some `inline code`."), "Here is some inline code.")
+
+    def test_fenced_code_blocks(self):
+        text = "Before code\n```python\ndef foo():\n    pass\n```\nAfter code"
+        self.assertEqual(llm_soup_to_text(text), "Before code\n\tAfter code")
+        
+        text2 = "Before code\n~~~javascript\nconsole.log(1);\n~~~\nAfter code"
+        self.assertEqual(llm_soup_to_text(text2), "Before code\n\tAfter code")
+
+    def test_headers(self):
+        text = "# Header 1\nSome text\n## Header 2\nMore text"
+        self.assertEqual(llm_soup_to_text(text), "Header 1\nSome text\nHeader 2\nMore text")
+        
+        text2 = "Setext Header\n=============\nSome text"
+        self.assertEqual(llm_soup_to_text(text2), "Setext Header\nSome text")
+
+    def test_links_and_images(self):
+        self.assertEqual(llm_soup_to_text("Click [here](https://url.com) now."), "Click here now.")
+        self.assertEqual(llm_soup_to_text("An image ![alt text](img.png) here."), "An image here.")
+
+    def test_blockquotes(self):
+        text = "> This is a quote\n> It continues"
+        self.assertEqual(llm_soup_to_text(text), "This is a quote\nIt continues")
+
+    def test_lists(self):
+        text = "- Item 1\n* Item 2\n+ Item 3"
+        self.assertEqual(llm_soup_to_text(text), "Item 1\nItem 2\nItem 3")
+        
+        text2 = "1. First\n2. Second\n10. Tenth"
+        self.assertEqual(llm_soup_to_text(text2), "First\nSecond\nTenth")
+
+    def test_html_tags(self):
+        self.assertEqual(llm_soup_to_text("<p>Hello <b>world</b>!</p>"), "Hello world!")
+        self.assertEqual(llm_soup_to_text("<div>Text <br/> More text</div>"), "Text\nMore text")
+
+    def test_html_comments(self):
+        self.assertEqual(llm_soup_to_text("Visible <!-- hidden --> visible"), "Visible visible")
+
+    def test_html_entities(self):
+        self.assertEqual(llm_soup_to_text("Tom &amp; Jerry"), "Tom & Jerry")
+        self.assertEqual(llm_soup_to_text("It&#39;s mine"), "It's mine")
+
+    def test_horizontal_rules(self):
+        text = "Above\n---\nBelow\n***\nEnd"
+        self.assertEqual(llm_soup_to_text(text), "Above\n\tBelow\n\tEnd")
+
+    def test_whitespace_and_paragraphs(self):
+        # Multiple spaces and tabs
+        self.assertEqual(llm_soup_to_text("Too   many \t spaces"), "Too many spaces")
+        # Paragraphs consolidated
+        self.assertEqual(llm_soup_to_text("Para 1\n\n\n\nPara 2"), "Para 1\n\tPara 2")
+        # Leading and trailing
+        self.assertEqual(llm_soup_to_text(" \n  \t Trim me \n \t  "), "Trim me")
+
+
+if __name__ == '__main__':
+    unittest.main()

thinking_machine-0.0.22/tests/test_utilities.py

@@ -0,0 +1,69 @@
+import unittest
+import json
+import os
+from src.thinking_machine.utilities import (
+    plato_text_to_cmj,
+    plato_text_to_muj,
+    plato_text_to_mpuj,
+    cmj_to_plato_text,
+    new_plato_text
+)
+
+
+class TestTransformations(unittest.TestCase):
+    def setUp(self):
+        # Paths to example files
+        base_dir = os.path.dirname(__file__) + '/data'
+        with open(os.path.join(base_dir, 'plato_example.txt'), 'r', encoding='utf-8') as f:
+            self.plato_txt = f.read()
+        
+        with open(os.path.join(base_dir, 'cmj_example.json'), 'r', encoding='utf-8') as f:
+            self.cmj_json = json.load(f)
+            
+        with open(os.path.join(base_dir, 'mpuj_example.json'), 'r', encoding='utf-8') as f:
+            self.mpuj_json = json.load(f)
+            
+        with open(os.path.join(base_dir, 'muj_example.json'), 'r', encoding='utf-8') as f:
+            self.muj_json = json.load(f)
+            
+        self.machine_name = "Thinking-Machine"
+        self.maxDiff = None
+
+    def test_plato_text_to_muj(self):
+        result = plato_text_to_muj(self.plato_txt, self.machine_name)
+        self.assertEqual(result, self.muj_json)
+
+    def test_plato_text_to_mpuj(self):
+        result = plato_text_to_mpuj(self.plato_txt, self.machine_name)
+        self.assertEqual(result, self.mpuj_json)
+
+    def test_plato_text_to_cmj(self):
+        result = plato_text_to_cmj(self.plato_txt, self.machine_name)
+        self.assertEqual(result, self.cmj_json)
+
+    def test_cmj_to_plato_text(self):
+        result = cmj_to_plato_text(self.cmj_json)
+        self.assertEqual(result.strip(), self.plato_txt.strip())
+
+    def test_new_plato_text(self):
+        thoughts = "This is a thought.\n\nIt spans multiple paragraphs."
+        text = "This is the final text.\n\nIt also has paragraphs."
+
+        expected = (
+            "Thinking-Machine: (thinking) This is a thought.\n\tIt spans multiple paragraphs.\n\n"
+            "Thinking-Machine: This is the final text.\n\tIt also has paragraphs.\n\n"
+        )
+        result = new_plato_text(thoughts, text, self.machine_name)
+        self.assertEqual(result, expected)
+
+        expected_no_thoughts = "Thinking-Machine: This is the final text.\n\tIt also has paragraphs.\n\n"
+        result2 = new_plato_text("", text, self.machine_name)
+        self.assertEqual(result2, expected_no_thoughts)
+
+        expected_no_text = "Thinking-Machine: (thinking) This is a thought.\n\tIt spans multiple paragraphs.\n\n"
+        result3 = new_plato_text(thoughts, "", self.machine_name)
+        self.assertEqual(result3, expected_no_text)
+
+
+if __name__ == '__main__':
+    unittest.main()