exploring-machine 0.0.1__py3-none-any.whl

exploring_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": "Exploring-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__':
+    ...

exploring_machine/providers/chinf.py

@@ -0,0 +1,86 @@
+# -*- 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, **kwargs):
+    """ All parameters should be in kwargs, but they are optional
+    """
+    # The configuration.
+    api_key = environ.get("CHINF_API_KEY", '')
+    default_model = environ.get("CHINF_DEFAULT_MODEL", 'gpt-5.6-luna')
+    api_base = environ.get("CHINF_API_BASE", "https://api.cheaperinference.com/v1")
+
+    # Set the mandatory headers
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}",
+        "X-Api-Key": api_key,
+        "Anthropic-Version": "2023-06-01",
+        "User-Agent": "chinf"
+    }
+
+    # Receive the instruction
+    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 initial payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "messages":         instruction_and_contents,
+        "max_tokens":       kwargs.get("max_tokens", 132000),
+        "reasoning_effort": "max",
+    }
+    # Convert
+    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)
+
+    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}")
+        output = {}
+
+    except urllib.error.URLError as e:
+        # Handle network/connection errors
+        print(f"Failed to reach the server: {e.reason}")
+        output = {}
+    # Discern what we got
+    result = output.get('choices', {})
+    if result:
+        completion_message = result[0]['message']
+        thoughts = completion_message.get('reasoning', '')
+        text = completion_message.get('content', '')
+    else:
+        thoughts = ''
+        text = ''
+
+    return thoughts, text
+
+
+if __name__ == "__main__":
+    ...

exploring_machine/providers/depsek.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, instructions, **kwargs):
+    """
+    """
+    api_key = environ.get("DEPSEK_API_KEY")
+    api_base = environ.get("DEPSEK_API_BASE", "https://api.deepseek.com")
+    default_model = environ.get("DEPSEK_DEFAULT_MODEL", "deepseek-flash")
+
+    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", default_model),
+        "messages":         instruction_and_contents,
+        "max_tokens":       kwargs.get("max_tokens", 64000),
+        "temperature":      kwargs.get("temperature", 1.0),
+        "reasoning_effort": kwargs.get("reasoning_effort", "max"),
+        "thinking": {
+            "type": "enabled"
+        }
+    }
+
+    # 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}/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)
+            message = output['choices'][0]['message']
+            text = message['content']
+            thoughts = message['reasoning_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__':
+    ...

exploring_machine/providers/electroid.py

@@ -0,0 +1,78 @@
+# -*- 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("ANTHROPIC_API_KEY")
+    api_base = environ.get("ANTHROPIC_API_BASE", "https://api.anthropic.com/v1")
+    api_type = environ.get("ANTHROPIC_VERSION", "2023-06-01")
+    default_model = environ.get("ANTHROPIC_DEFAULT_MODEL", 'claude-opus-4-6')
+
+    # Define the payload
+    payload = {
+        "model": kwargs.get("model", default_model),
+        "thinking": {"type": "adaptive"},
+        "system": kwargs.get("system_instruction", instructions),
+        "messages": messages,
+        "max_tokens": kwargs.get("max_tokens", 100000),
+        "stop_sequences": kwargs.get("stop_sequences", ['stop']),
+        "stream": kwargs.get("stream", False),
+        "temperature": 1.0,
+        "output_config": kwargs.get("output_config", {"effort": "low"}),
+        "metadata": kwargs.get("metadata", None)
+    }
+
+    # Convert data dictionary to JSON and encode it to bytes
+    data_bytes = json.dumps(payload).encode('utf-8')
+
+    headers = {
+        "x-api-key": api_key,
+        "anthropic-version": api_type,
+        "content-type": "application/json",
+        "User-Agent": "Exploring-Machine"
+    }
+
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/messages',
+        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 chunk in output.get("content"):
+                if chunk['type'] == 'text':
+                    addition = chunk['text']
+                    if addition not in ('\n\n', '\n'):
+                        text += addition
+
+                elif chunk['type'] == 'thinking':
+                    thoughts += chunk['thinking']
+
+            return thoughts, text
+
+    except Exception as e:
+        print("Unable to generate Message response")
+        print(f"Exception: {e}")
+        return ['', '']
+
+
+if __name__ == "__main__":
+    ...

exploring_machine/providers/illuminati.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 json
+import urllib.request
+import urllib.error
+from os import environ
+
+
+def decode_output(output):
+    # Parse the result
+    text = ''; thoughts = ''
+    for part in output:
+        part_type = part.get('type', None)
+        if part_type == 'message':
+            text = " ".join([chunk['text'] for chunk in part['content'] if chunk['type'] == 'output_text'])
+        elif part_type == 'reasoning':
+            thoughts = " ".join([chunk['text'] for chunk in part['summary'] if chunk['type'] == 'summary_text'])
+    function_calls = [part for part in output if part['type'] == 'function_call']
+    return thoughts, text, function_calls
+
+
+def respond(messages=None, instructions=None, tools=None, **kwargs):
+    """ All parameters should be in kwargs, but they are optional
+    """
+    # The configuration.
+    api_key = environ.get('FIREWORKS_API_KEY')
+    api_base = environ.get('FIREWORKS_BASE_URL', 'https://api.fireworks.ai/inference/v1')
+    default_model = environ.get('FIREWORKS_MODEL', 'accounts/fireworks/models/kimi-k3')
+
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + api_key,
+        "User-Agent": "Exploring-Machine"
+    }
+
+    # Receive the instruction
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the initial payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "instructions":     instruction,
+        "input":            messages,
+        "max_output_tokens": kwargs.get("max_tokens", 132000),
+        "reasoning": {
+            "effort": "max",
+            "summary": "detailed"
+        }
+    }
+    # Convert data dictionary to JSON and encode it to bytes
+    data_bytes = json.dumps(payload).encode('utf-8')
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/responses',
+        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)
+            thoughts, text, function_calls = decode_output(output.get('output', {}))
+
+    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 '', ''
+
+    return thoughts, text
+
+
+if __name__ == "__main__":
+    ...

exploring_machine/providers/metai.py

@@ -0,0 +1,164 @@
+# -*- 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
+
+api_key = environ.get("METAI_API_KEY", '')
+default_model = environ.get("METAI_DEFAULT_MODEL", 'muse-spark-1.1')
+api_base = environ.get("METAI_API_BASE", "https://api.meta.ai/v1")
+
+
+# Set the mandatory headers
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {api_key}",
+    "User-Agent": "Exploring-Machine"
+}
+
+
+def get_weather(location):
+    # print(f"Executing weather tool for location: {location}")
+    return {"temperature": "72F", "condition": "Sunny"}
+
+
+def query(payload):
+    # Convert data dictionary to JSON and encode it to bytes
+    data_bytes = json.dumps(payload).encode('utf-8')
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}/responses',
+        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)
+        return output
+
+    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 {}
+
+
+def decode_output(output):
+    # Parse the result
+    text = ''; thoughts = ''
+    for part in output:
+        part_type = part.get('type', None)
+        if part_type == 'message':
+            text = " ".join([chunk['text'] for chunk in part['content'] if chunk['type'] == 'output_text'])
+        elif part_type == 'reasoning':
+            thoughts = " ".join([chunk['text'] for chunk in part['summary'] if chunk['type'] == 'summary_text'])
+    function_calls = [part for part in output if part['type'] == 'function_call']
+    return thoughts, text, function_calls
+
+
+def respond(messages=None, instructions=None, tools=None, **kwargs):
+    """ All parameters should be in kwargs, but they are optional
+    """
+    # Receive the instruction
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the initial payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "instructions":     instruction,
+        "input":            messages,
+        "max_output_tokens": kwargs.get("max_tokens", 132000),
+        "prompt_cache_retention": "in_memory",
+        "include": ["reasoning.encrypted_content"],
+        "reasoning": {
+            "effort": "high",
+            "summary": "detailed"
+        }
+    }
+    # Tools if there are some
+    if tools:
+        payload['tools'] = tools
+        payload['tool_choice'] = 'auto'
+
+    while True:
+        # Query the API
+        result = query(payload)
+        # id of the response
+        response_id = result['id']
+        thoughts, text, function_calls = decode_output(result.get('output', {}))
+
+        if function_calls:
+            function_outputs_messages = []
+            for function_call in function_calls:
+                call_id = function_call.get('call_id')
+                func_name = function_call.get('name')
+                func_args_str = function_call.get('arguments', '{}')
+                try:
+                    if isinstance(func_args_str, str):
+                        func_args = json.loads(func_args_str)
+                    else:
+                        func_args = func_args_str
+                except Exception as e:
+                    func_args = {}
+                    print(f"Error parsing tool arguments for {func_name}: {e}")
+
+                # Look up tool by name in globals and caller frames
+                func = globals().get(func_name)
+                if not func:
+                    import inspect
+                    frame = inspect.currentframe().f_back
+                    while frame:
+                        if func_name in frame.f_globals:
+                            func = frame.f_globals[func_name]
+                            break
+                        frame = frame.f_back
+
+                if func and callable(func):
+                    try:
+                        tool_result = func(**func_args)
+                        if isinstance(tool_result, (dict, list)):
+                            result = json.dumps(tool_result)
+                        else:
+                            result = str(tool_result)
+                    except Exception as e:
+                        result = f"Error executing tool {func_name}: {str(e)}"
+                        print(result)
+                else:
+                    result = f"Error: Tool function {func_name} not found."
+                    print(result)
+
+                tool_message = {
+                    "type": "function_call_output",
+                    "call_id": call_id,
+                    "output": result
+                }
+                function_outputs_messages.append(tool_message)
+
+            # Now that all responses have been gathered
+            # we can change the payload and send them back
+            payload['include'] = [] # must be removed if response_id
+            payload['previous_response_id'] = response_id
+            payload['input'] = function_outputs_messages
+        else:
+            break
+
+    return thoughts, text
+
+
+if __name__ == "__main__":
+    ...