exploring-machine 0.0.1__py3-none-any.whl

exploring_machine/providers/openai.py

@@ -0,0 +1,82 @@
+# -*- 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):
+    """ All parameters should be in kwargs, but they are optional
+    """
+    api_key = environ.get("OPENAI_API_KEY", '')
+    default_model = environ.get("OPENAI_DEFAULT_MODEL", 'gpt-5.4')
+    api_base = environ.get("OPENAI_API_BASE", "https://api.openai.com/v1")
+
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "instructions":     instruction,
+        "input":            messages,
+        "max_output_tokens": kwargs.get("max_tokens", 64000),
+        "reasoning": {
+            "effort": "xhigh",
+            "summary": "detailed"
+        }
+    }
+
+    # 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": "Exploring-Machine"
+    }
+
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/responses',
+        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 = ''
+            for part in output['output']:
+                if part['type'] == 'message':
+                    for chunk in part['content']:
+                        text += chunk['text']
+                elif part['type'] == 'reasoning':
+                    for chunk in part['summary']:
+                        thoughts += chunk['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__":
+    ...

exploring_machine/providers/qrog.py

@@ -0,0 +1,82 @@
+# -*- 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):
+    """
+    Sends a request to the Groq Responses API using only Python's built-in urllib.
+    """
+    api_base = environ.get('GROQ_API_BASE', 'https://api.groq.com/openai/v1')
+    api_key = environ.get('GROQ_API_KEY', '')
+    default_model = environ.get('GROQ_DEFAULT_MODEL', 'openai/gpt-oss-120b')
+
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the payload
+    payload = {
+        "model": kwargs.get("model", default_model),
+        "instructions": instruction,
+        "input": messages,
+        "max_output_tokens": kwargs.get("max_tokens", 65536),
+        "reasoning": {
+            "effort": "high"
+        }
+    }
+
+    # 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": "Exploring-Machine"
+    }
+
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/responses',
+        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 = ''
+            for part in output['output']:
+                if part['type'] == 'message':
+                    for chunk in part['content']:
+                        text += chunk['text']
+                elif part['type'] == 'reasoning':
+                    for chunk in part['content']:
+                        thoughts += chunk['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__":
+    ...

exploring_machine/providers/strangelove.py

@@ -0,0 +1,81 @@
+# -*- 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, instructions, **kwargs):
+    """
+    """
+    api_key = environ.get("XAI_API_KEY")
+    api_base = environ.get("XAI_API_BASE", "https://api.x.ai/v1")
+    default_model = environ.get("XAI_DEFAULT_MODEL", "grok-4.20-reasoning")
+
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the payload
+    payload = {
+        "model": kwargs.get("model", default_model),
+        "instructions": instructions,
+        "input": messages,
+        "max_output_tokens": kwargs.get("max_tokens", 64000),
+        "reasoning": {
+            "summary": "detailed"
+        }
+    }
+
+    # Convert data dictionary to JSON and encode it to bytes
+    data_bytes = json.dumps(payload).encode('utf-8')
+
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + api_key,
+        "User-Agent": "Exploring-Machine"
+    }
+
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/responses',
+        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 = ''
+            for part in output['output']:
+                if part['type'] == 'message':
+                    for chunk in part['content']:
+                        text += chunk['text']
+                elif part['type'] == 'reasoning_content':
+                    for chunk in part['summary']:
+                        thoughts += chunk['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__':
+    ...

exploring_machine/providers/tinker.py

@@ -0,0 +1,83 @@
+# -*- 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 json
+import urllib.request
+import urllib.error
+from os import environ
+
+
+def respond(messages=None, instructions=None, tools=None, **kwargs):
+    """ They don't have responses, emulation through chat completions.
+    """
+    api_key = environ.get("TINKER_API_KEY", '')
+    default_model = environ.get("TINKER_DEFAULT_MODEL", 'thinkingmachines/Inkling')
+    api_base = environ.get("TINKER_OAI_API_BASE", 'https://tinker.thinkingmachines.dev/services/tinker-prod/oai/api/v1')
+
+    # Set the mandatory headers
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}",
+        "User-Agent": "Exploring-Machine"
+    }
+
+    instruction         = kwargs.get('system_instruction', instructions)
+    first_message       = [dict(role='system', content=instruction)] if instruction else []
+
+    # contents can come in kwards or as an argument
+    messages            = kwargs.get('messages', messages)
+
+    first_message.extend(messages)
+    instruction_and_contents = first_message
+
+    payload = {
+        'model': kwargs.get('model', default_model),
+        'messages': instruction_and_contents,
+        # 'response_format':          kwargs.get('response_format',{'type': 'text'}),
+        'temperature': kwargs.get('temperature', 1),  # 0.0 to 2.0
+        'max_tokens': kwargs.get('max_tokens', 4096),
+        'n': kwargs.get('n', 1),
+        'top_p': kwargs.get('top_p', 0.9),
+        'separate_reasoning': True,
+        'reasoning_effort': kwargs.get('reasoning_effort', 'high'),  # 'low', 'medium', 'high'
+        'stream': False
+    }
+
+    data_bytes = json.dumps(payload).encode('utf-8')
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/chat/completions',
+        data=data_bytes,
+        headers=headers,
+        method="POST")
+
+    # Try to query
+    try:
+        # Execute the request
+        with urllib.request.urlopen(req, timeout=3000) as response:
+            response_data = response.read().decode('utf-8')
+            output = json.loads(response_data)
+            completion_message = output['choices'][0]['message']
+            thoughts = completion_message.get('reasoning_content', '')
+            text = completion_message.get('content', '')
+        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__':
+   ...