reckoning-machine 0.0.1__py3-none-any.whl

reckoning_machine/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from .config import Config
+from .machine import machine
+from .githf import fetch_instructions
+from .utilities import (plato_text_to_muj,
+                        plato_text_to_mpuj,
+                        llm_soup_to_text,
+                        new_plato_text)
+
+__all__ = [
+    'machine',
+    'fetch_instructions',
+    'Config'
+]

reckoning_machine/cli.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+import os
+import sys
+import select
+import fileinput
+import argparse
+import syslog
+from .config import Config
+from .utilities import new_plato_text
+
+
+def options_and_arguments():
+    # Initialize the parser
+    parser = argparse.ArgumentParser(
+        description="Reckoning-Machine thinks for you about the meanings.",
+        epilog="Example:  reckoning-machine input_text.txt > output_text.txt"
+        # thinking-machine -a multilogue.txt > tmp && mv tmp multilogue.txt
+    )
+
+    # Give the access key and token, or set the environment variables in advance.
+    parser.add_argument('-p', '--provider-api-key',
+                        default=os.getenv('PROVIDER_API_KEY', 'no_key'),
+                        help="LLM provider API key (defaults to $PROVIDER_API_KEY)")
+    parser.add_argument('-g', '--github-token',
+                        default=os.getenv('GITHUB_TOKEN', 'no_token'),
+                        help="GitHub API token (defaults to $GITHUB_TOKEN)")
+
+    parser.add_argument('-a', '--append',
+                        action='store_true',
+                        help="Append the utterance to the input.")
+
+    parser.add_argument('-d', '--debug',
+                        action='store_true',
+                        help="Debug flag.")
+
+    # Add the interactive flag
+    # parser.add_argument('-i', '--interactive',
+    #                     action='store_true',
+    #                     help="Enable interactive mode (defaults to False)")
+
+    # Positional arguments (files)
+    # '*' captures zero or more arguments into a list, nargs='+' one or more.
+    parser.add_argument('filenames',
+                        nargs='*',
+                        help="Zero (when text comes though a pipe) or more files to process.")
+    return parser
+
+
+def run():
+    """
+    $ text | reckoning-machine                        # Accepts text from the pipe
+    $ echo "...<text>..." | reckoning-machine         #
+
+    $ reckoning-machine multilogue.txt new_turn.txt    # ...or files.
+    """
+
+    args = options_and_arguments().parse_args()
+
+    # If no files are provided AND no data is being piped in - exit.
+    if not args.filenames:
+        # Check if stdin (fd 0) is ready to be read
+        readable, _, _ = select.select([sys.stdin], [], [], 0.1)
+        if not readable:
+            print("Error: No input files or piped text stream.")
+            options_and_arguments().print_help()
+            sys.exit(1)
+
+    config = Config()
+    
+    if args.provider_api_key:
+        if args.provider_api_key.startswith('sk-'):
+            if args.provider_api_key.startswith('sk-proj-'):
+                config.provider = 'OpenAI'
+                os.environ['OPENAI_API_KEY'] = args.provider_api_key
+            elif args.provider_api_key.startswith('sk-ant-'):
+                config.provider = 'Anthropic'
+                os.environ['ANTHROPIC_API_KEY'] = args.provider_api_key
+            else:
+                config.provider = 'DepSek'
+                os.environ['DEPSEK_API_KEY'] = args.provider_api_key
+        elif args.provider_api_key.startswith('AIzaSy'):
+            config.provider = 'Gemini'
+            os.environ['GEMINI_API_KEY'] = args.provider_api_key
+        elif args.provider_api_key.startswith('gsk_'):
+            config.provider = 'Groq'
+            os.environ['GROQ_API_KEY'] = args.provider_api_key
+        elif args.provider_api_key.startswith('xai-'):
+            config.provider = 'XAI'
+            os.environ['XAI_API_KEY'] = args.provider_api_key
+        elif args.provider_api_key.startswith('LLM|'):
+            config.provider = 'Meta'
+            os.environ['META_API_KEY'] = args.provider_api_key
+        elif args.provider_api_key == 'no_provider_key':
+            sys.stderr.write(f'No provider key!\n')
+            sys.stderr.flush()
+            sys.exit(1)
+        else:
+            if config.provider == '':
+                raise ValueError(f"Unrecognized API key prefix and no provider specified.")
+                
+        config.provider_api_key = args.provider_api_key
+        
+    if args.github_token:
+        config.github_token = args.github_token
+        os.environ['GITHUB_TOKEN'] = args.github_token
+
+    # Ingest files line by line. Join is here for long files.
+    lines = []
+    for line in fileinput.input(files=args.filenames or ['-'], encoding="utf-8"):
+        lines.append(line)
+    raw_input = "".join(lines)
+
+    from .machine import machine
+
+    try:
+        thoughts, text = machine(raw_input, config)
+        output = new_plato_text(thoughts, text, config.name)
+        if args.append:
+            output = raw_input +'\n\n' + output
+        sys.stdout.write(output)
+        sys.stdout.flush()
+
+        # Assesment and signals.
+        utterance = "My answer is ready"
+        # Open syslog connection
+        syslog.openlog(
+            ident="reckoning-machine",
+            logoption=syslog.LOG_NDELAY,
+            facility=syslog.LOG_USER
+        )
+        # Signal (single line less than 4096 only!)
+        syslog.syslog(syslog.LOG_INFO, f"reckoning-machine: {utterance}.")
+        syslog.closelog()
+
+    except Exception as e:
+        if args.debug:
+            import traceback
+            traceback.print_exc()
+        else:
+            sys.stderr.write(f'Machine did not work {e}\n')
+            sys.stderr.flush()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    run()

reckoning_machine/config.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from os import environ
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Config:
+    github_token: str               = field(default_factory=lambda: environ.get('GITHUB_TOKEN', ''))
+    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', ''))
+    machine_organization_name: str  = field(default_factory=lambda: environ.get('MACHINE_ORGANIZATION_NAME', 'reckoning-machine'))
+    private_repo_with_text: str     = field(default_factory=lambda: environ.get('PRIVATE_REPO_WITH_TEXT','reckoning_machine'))
+    system_prompt_file: str         = field(default_factory=lambda: environ.get('SYSTEM_PROMPT_FILE', 'machina.yaml'))
+    name: str                       = ''
+    instructions: str               = ''

reckoning_machine/githf.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+import sys
+from os import path
+import yaml
+import urllib.request
+import urllib.error
+
+
+def download_github_file(owner, repo, file_path, token):
+    """
+    Downloads a file from a GitHub repository using the GitHub REST API.
+    We request the raw content by using the 'application/vnd.github.v3.raw' accept header.
+    """
+    url = f"https://api.github.com/repos/{owner}/{repo}/contents/{file_path}"
+
+    headers = {
+        "Authorization": f"token {token}",
+        "Accept": "application/vnd.github.v3.raw",
+        "User-Agent": "Reckoning-Machine"
+    }
+
+    req = urllib.request.Request(url, headers=headers)
+
+    try:
+        with urllib.request.urlopen(req, timeout=10) as response:
+            return response.read()
+    except urllib.error.HTTPError as e:
+        print(f"HTTP Error {e.code}: {e.reason}")
+        error_info = e.read().decode('utf-8')
+        print(f"Details: {error_info}")
+        return None
+    except urllib.error.URLError as e:
+        print(f"URL Error: {e.reason}")
+        return None
+
+
+def fetch_instructions(config):
+    """Retrieve the system prompt from a private GitHub repo.
+    Falls back to the local machina.yaml if GitHub is unreachable.
+    Returns the 'name' of the Machine in dashed format.
+    Returns the 'description' field from the YAML as the system prompt string.
+    """
+    try:
+        raw_yaml = download_github_file(
+            owner=config.machine_organization_name,
+            repo=config.private_repo_with_text,
+            file_path=config.system_prompt_file,
+            token=config.github_token
+        )
+    except Exception as e:
+        print(f"Warning: could not fetch the instructions from GitHub: {e}",
+              file=sys.stderr)
+        local_path = path.join(path.dirname(__file__), 'machina.yaml')
+        with open(local_path, 'r') as f:
+            raw_yaml = f.read()
+
+    # Parse
+    parsed = yaml.safe_load(raw_yaml)
+    name = parsed.get('name')
+    config.name = name
+    instructions = parsed.get('description', 'You are a helpful assistant.')
+    config.instructions = instructions
+    return name, instructions

reckoning_machine/machina.yaml

@@ -0,0 +1,7 @@
+# Copyright (c) Alexander Fedotov, 2026. All rights reserved.
+name: Reckoning-Machine
+description: The Assistant is Reckoning-Machine. Reckoning-Machine does its best to understand
+  the conversation that it is participating in and answers in a most thoughtful way possible
+  the questions that it is being asked. 
+  Reckoning-Machine responds in plain text without any markdown, emphasis or lists. All 
+  paragraphs except the first should begin with a newline and tab.

reckoning_machine/machine.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+import sys
+from os import environ, path
+from .githf import fetch_instructions
+from .utilities import (plato_text_to_muj,
+                        plato_text_to_mpuj,
+                        plato_text_to_cmj,
+                        llm_soup_to_text)
+
+
+def machine(plato_text, config, **kwargs):
+    """Core agent logic.
+
+    1. Fetches the system prompt from a private GitHub repo.
+    2. Calls Provider
+    3. Returns a (thoughts, text) tuple.
+    """
+    # Fetch the confidential system prompt, name is for a checkup.
+    name, system_prompt = fetch_instructions(config)
+
+    # Load an appropriate library and query the API.
+    provider = config.provider
+    api_key  = config.provider_api_key
+    
+    if provider == 'OpenAI':
+        # Transform plato_text to MUJ format
+        messages = plato_text_to_muj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call OpenAI API via opehaina
+        environ['OPENAI_API_KEY'] = api_key
+        try:
+            from .providers import openai
+        except ImportError:
+            print("openai module is missing.", file=sys.stderr)
+            sys.exit(1)
+            
+        thoughts, text = openai.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        thoughts = llm_soup_to_text(thoughts)
+        return thoughts, text
+
+    elif provider == 'Gemini':
+        # Transform plato_text to MPUJ format
+        messages = plato_text_to_mpuj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call Gemini through castor-polux
+        environ['GEMINI_API_KEY'] = api_key
+        try:
+            from .providers import castor_pollux
+        except ImportError:
+            print("No module castor-pollux", file=sys.stderr)
+            sys.exit(1)
+            
+        thoughts, text = castor_pollux.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        thoughts = llm_soup_to_text(thoughts)
+        return thoughts, text
+
+    elif provider == 'Anthropic':
+        # Transform plato_text to MUJ format
+        messages = plato_text_to_muj(plato_text=plato_text,
+                                     machine_name=name)
+
+        # Call the Anthropic API via electroid
+        environ['ANTHROPIC_API_KEY'] = api_key
+        try:
+            from .providers import electroid
+        except ImportError:
+            print("no electroid module", file=sys.stderr)
+            sys.exit(1)
+            
+        text, thoughts = electroid.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+        return text, thoughts
+
+    elif provider == 'Groq':
+        # Transform plato_text to MUJ format
+        messages = plato_text_to_muj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call OpenAI API via opehaina
+        environ['GROQ_API_KEY'] = api_key
+        try:
+            from .providers import qrog
+        except ImportError:
+            print("openai module is missing.", file=sys.stderr)
+            sys.exit(1)
+
+        thoughts, text = qrog.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        thoughts = llm_soup_to_text(thoughts)
+        return thoughts, text
+
+    elif provider == 'Xai':
+        # Transform plato_text to MUJ format
+        messages = plato_text_to_muj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call OpenAI API via opehaina
+        environ['XAI_API_KEY'] = api_key
+        try:
+            from .providers import strangelove
+        except ImportError:
+            print("openai module is missing.", file=sys.stderr)
+            sys.exit(1)
+
+        thoughts, text = strangelove.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        thoughts = llm_soup_to_text(thoughts)
+        return thoughts, text
+
+    elif provider == 'DepSek':
+        # Transform plato_text to CMJ format
+        messages = plato_text_to_cmj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call OpenAI API via opehaina
+        environ['DEPSEK_API_KEY'] = api_key
+        try:
+            from .providers import depsek
+        except ImportError:
+            print("openai module is missing.", file=sys.stderr)
+            sys.exit(1)
+
+        thoughts, text = depsek.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        return thoughts, text
+
+    elif provider == 'Meta':
+        # Transform plato_text to CMJ format
+        messages = plato_text_to_cmj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call OpenAI API via opehaina
+        environ['META_API_KEY'] = api_key
+        try:
+            from .providers import camelids
+        except ImportError:
+            print("openai module is missing.", file=sys.stderr)
+            sys.exit(1)
+
+        thoughts, text = camelids.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        return thoughts, text
+
+
+if __name__ == '__main__':
+    print('You have launched main')

reckoning_machine/providers/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""

reckoning_machine/providers/camelids.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+import urllib.request
+import urllib.error
+import json
+from os import environ
+
+
+def respond(messages=None, instructions=None, **kwargs):
+    """A continuation of text with a given context and instruction.
+        kwargs:
+            temperature     = 0 to 1.0
+            top_p           = 0.0 to 1.0
+            top_k           = The maximum number of tokens to consider when sampling.
+            n               = 1 is mandatory for this method continuationS have n > 1
+            max_tokens      = number of tokens
+            stop            = ['stop']  array of up to 4 sequences
+    """
+    api_key = environ.get('META_API_KEY', '')  # meta_KEY', '')
+    api_base = environ.get('META_API_BASE', 'https://api.llama.com/v1')
+    content_model = environ.get('META_DEFAULT_CONTENT_MODEL', 'Llama-4-Maverick-17B-128E-Instruct-FP8')
+
+    instruction         = kwargs.get('system_instruction', instructions)
+    first_message       = [dict(role='system', content=instruction)] if instruction else []
+
+    # add contents and user text to the first (instruction) message
+    first_message.extend(messages)
+    instruction_and_contents = first_message
+
+    # Define the payload
+    payload = {
+        'model':                    kwargs.get('model', content_model),
+        'messages':                 instruction_and_contents,
+        'response_format':          kwargs.get('response_format',{'type': 'text'}),
+        'temperature':              kwargs.get('temperature', 1.0),  # 0.0 to 1.0
+        'max_completion_tokens':    kwargs.get('max_tokens', 4028),
+        'top_p':                    kwargs.get('top_p', 0.9),
+        'top_k':                    kwargs.get('top_k', 10),
+        'stream':                   False
+    }
+
+    # Convert data dictionary to JSON and encode it to bytes
+    data_bytes = json.dumps(payload).encode('utf-8')
+
+    # Set the mandatory headers
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}",
+        "User-Agent": "Reckoning-Machine"
+    }
+
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/chat/completions',
+        data=data_bytes,
+        headers=headers,
+        method="POST")
+
+    try:
+        # Execute the request
+        with urllib.request.urlopen(req, timeout=300) as response:
+            response_data = response.read().decode('utf-8')
+            output = json.loads(response_data)
+            text = output['completion_message']['content']['text']
+
+        return '', text
+
+    except urllib.error.HTTPError as e:
+        # Handle HTTP errors (e.g., 401 Unauthorized, 400 Bad Request)
+        error_info = e.read().decode('utf-8', errors='ignore')
+        print(f"HTTP Error {e.code}: {e.reason}")
+        print(f"Error Details: {error_info}")
+        return '', ''
+
+    except urllib.error.URLError as e:
+        # Handle network/connection errors
+        print(f"Failed to reach the server: {e.reason}")
+        return '', ''
+
+
+if __name__ == '__main__':
+    ...

reckoning_machine/providers/castor_pollux.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+import urllib.request
+import urllib.error
+import urllib.parse
+import json
+from os import environ
+from ..utilities import messages_to_mpj
+
+
+def respond(messages=None, instructions=None, **kwargs):
+    """
+    """
+    api_key = environ.get('GEMINI_API_KEY', '')
+    api_base = environ.get('GEMINI_API_BASE', 'https://generativelanguage.googleapis.com/v1beta')
+    content_model = environ.get('GEMINI_DEFAULT_CONTENT_MODEL', 'gemma-4-31b-it')
+
+    garbage = [
+        {'category': 'HARM_CATEGORY_HATE_SPEECH', 'threshold': 'BLOCK_NONE'},
+        {'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'threshold': 'BLOCK_NONE'},
+        {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'threshold': 'BLOCK_NONE'},
+        {'category': 'HARM_CATEGORY_HARASSMENT', 'threshold': 'BLOCK_NONE'},
+        {'category': 'HARM_CATEGORY_CIVIC_INTEGRITY', 'threshold': 'BLOCK_NONE'}
+    ]
+
+    instructions = kwargs.get('system_instruction', instructions)
+    system_instruction = dict(role='system', parts=[dict(text=instructions)]) if instructions else None
+
+    # Trickery for thinking models
+    thinking_config = None
+    model = kwargs.get("model", content_model)
+    if model.startswith('gemini-2.5'):
+        thinking_config = {
+            'includeThoughts': kwargs.get('include_thoughts', True),
+            'thinkingBudget': kwargs.get('thinking_budget', 10000)
+        }
+    elif model.startswith('gemini-3'):
+        thinking_config = {
+            'includeThoughts': kwargs.get('include_thoughts', True),
+            'thinkingLevel': kwargs.get('thinking_level', 'high')
+        }
+    elif model.startswith('gemma-4'):
+        thinking_config = {
+            'includeThoughts': kwargs.get('include_thoughts', True)
+        }
+
+    # Define the payload
+    payload = {
+        'systemInstruction': system_instruction,
+        'contents': messages,
+        'safetySettings': garbage,
+        'generationConfig': {
+            'stopSequences': kwargs.get('stop_sequences', ['STOP', 'Title']),
+            'responseMimeType': kwargs.get('mime_type', 'text/plain'),
+            'responseModalities': kwargs.get('modalities', ['TEXT']),
+            'temperature': kwargs.get('temperature', 1.0),
+            'maxOutputTokens': kwargs.get('max_tokens', 10000),
+            'topP': kwargs.get('top_p', 0.9),
+            'topK': kwargs.get('top_k', 10),
+            'enableEnhancedCivicAnswers': False,
+        },
+    }
+    if thinking_config:
+        payload['generationConfig']['thinkingConfig'] = thinking_config
+    if kwargs.get('sources'):
+        payload['tools'].append(
+            {
+                "url_context": {}
+            }
+        )
+
+    # Convert data dictionary to JSON and encode it to bytes
+    data_bytes = json.dumps(payload).encode('utf-8')
+
+    # Set the mandatory headers
+    headers = {
+        "Content-Type": "application/json",
+        "User-Agent": "Reckoning-Machine"
+    }
+
+    # urlencode parameter
+    params = urllib.parse.urlencode({'key': api_key})
+
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/models/{kwargs.get("model", content_model)}:generateContent?{params}',
+        data=data_bytes,
+        headers=headers,
+        method="POST")
+
+    try:
+        # Execute the request
+        with urllib.request.urlopen(req, timeout=300) as response:
+            response_data = response.read().decode('utf-8')
+            output = json.loads(response_data)
+            text = ''
+            thoughts = ''
+            if output['candidates'][0]['finishReason'] == 'SAFETY':
+                raise Exception('Answer censored by Google.')
+            for part in output['candidates'][0]['content']['parts']:
+                if part.get('thought'):
+                    thoughts += part['text']
+                else:
+                    text += part['text']
+
+        return thoughts, text
+
+    except urllib.error.HTTPError as e:
+        # Handle HTTP errors (e.g., 401 Unauthorized, 400 Bad Request)
+        error_info = e.read().decode('utf-8', errors='ignore')
+        print(f"HTTP Error {e.code}: {e.reason}")
+        print(f"Error Details: {error_info}")
+        return '', ''
+
+    except urllib.error.URLError as e:
+        # Handle network/connection errors
+        print(f"Failed to reach the server: {e.reason}")
+        return '', ''
+
+
+if __name__ == '__main__':
+    ...