index.js

import { Hecto, Result } from "hecto";

class Py extends Hecto {
  get hardcode() {
    const that = this;

    return {
      setupString: `import sys
import json
import math
import traceback
import types
import copy
from collections.abc import MutableMapping, MutableSequence, Set

def copy(d):
    if isinstance(d, MutableMapping):
        return {k: v for k, v in d.items() if v is not __builtins__.__dict__}
    if isinstance(d, types.ModuleType):
        return copy(vars(d))
    elif isinstance(d, (list, set, tuple)): 
        return type(d)(copy(item) for item in d)
    else:
        return d

previous_globals = dict()
def sync_globals():
    mutated_globals = {}
    for key, value in globals().items():
      if copy(value) != previous_globals.get(key) and key not in ['previous_globals']:
        # global builtins are fetched once
        if key in ['__builtins__', 'builtins'] and previous_globals.get(key) != None:
            continue
        previous_globals[key] = copy(value)
        mutated_globals[key] = copy(value)
    return mutated_globals

def convert_to_serializable(obj, memo=None):
    if isinstance(obj, (int, str, bool, type(None))):
        return obj
    elif isinstance(obj, float):
        if math.isnan(obj):
            return "<NaN>"
        elif math.isinf(obj):
            return "<Infinity>" if obj > 0 else "<-Infinity>"
        return obj
    elif isinstance(obj, types.FunctionType):
        return f"<def>{obj.__name__}"
    if memo is None:
        memo = set()
    if id(obj) in memo:
        return "<circular>"
    memo.add(id(obj))
    if isinstance(obj, MutableMapping):
        return {convert_to_serializable(k, memo): convert_to_serializable(v, memo) for k, v in obj.items()}
    elif isinstance(obj, MutableSequence):
        return [convert_to_serializable(item, memo) for item in obj]
    elif isinstance(obj, Set):
        return [convert_to_serializable(item, memo) for item in obj]
    elif isinstance(obj, types.MappingProxyType):
        return convert_to_serializable(dict(obj), memo)
    elif hasattr(obj, '__dict__'):
        return convert_to_serializable(vars(obj), memo)
    elif isinstance(obj, type):
        return f"<cls>{obj.__name__}>"
    elif isinstance(obj, types.ModuleType):
        return f"<lib>{obj.__name__}"
    elif isinstance(obj, property):
        getter_value = obj.fget() if obj.fget else None
        return convert_to_serializable(getter_value, memo)
    elif isinstance(obj, object):
        return f"<obj>{type(obj).__name__}"
    else:
        return "<unknown>"

hecto_original_print = print

def emit(event, *args):
    hecto_original_print('¬-' + event + '¬&' + json.dumps(convert_to_serializable(list(args))) + '-¬')

def print(*args):
    emit('print', *args)

def hecto_display(value):
    if value is not None:
        hecto_original_print('¬¬' + json.dumps(convert_to_serializable(value)) + '¬¬')

def hecto_except(type, value, traceback_obj):
    filename, line_number, line_text, line_pos, error_code = None, None, None, None, None
    tb_list = None
    try:
        traceback.extract_tb(traceback_obj)
    except Exception:
        pass
    if tb_list:
        filename, line_number, function_name, line_text = tb_list[-1]
        line_pos = traceback_obj.tb_lineno
        error_code = value.args[0] if value.args else None
    hecto_original_print('¬*' + json.dumps({'fn': filename, 'line': line_number, 'msg': error_code, 'name': type.__name__, 'pos': line_pos}) + '*¬')

sys.displayhook = hecto_display
#sys.excepthook = hecto_except

def hecto_ret(additional = None):
    value = sync_globals()
    if additional is not None:
      value = additional;
    hecto_original_print('¬^' + json.dumps(convert_to_serializable(value)) + '^¬')

hecto_ret()
`,
      defaultShellNames: ["python3", "python"],
      setup() {
        that.__raw_write(this.setupString);
      },
      writeExecutionCommand(command) {
        return that.__raw_write(`${command.trim()}\n\nhecto_ret()\n`);
      },
      context: {
        get(
          prop,
          value, 
          { type } = {}
        ) {
          switch (type) {
            case "def":
              return async (...args) => {
                return await that.exec(
                  `${prop}(${args.map(JSON.stringify).join(",")})`
                );
              };
            default:
              return value;
          }
        },
        set(prop, value, oldValue) {
          switch (typeof value) {
            case "function":
              return oldValue; // Ignore
            default:
              that.exec(`${prop} = ${JSON.stringify(value)}`);
              return value;
          }
        },
      },
    };
  }
}

export { Py, Result };