klongpy 0.6.9__py3-none-any.whl → 0.7.1__py3-none-any.whl

klongpy-0.6.9.data/scripts/kgpy → klongpy/cli.py

@@ -1,27 +1,29 @@
-#!python
+#!/usr/bin/env python3
+"""
+KlongPy REPL command-line interface.
+
+See https://t3x.org/klong/klong-ref.txt.html for additional details.
+"""
 
 import argparse
 import asyncio
+import importlib
+import importlib.util
 import importlib.metadata
 import os
 import sys
 import threading
-import time
 import timeit
 
 import colorama
 
-from klongpy import KlongInterpreter
+from klongpy import KlongInterpreter, list_backends
 from klongpy.core import kg_write
-from klongpy.utils import CallbackEvent
-
-import importlib.resources
-
-"""
+from klongpy.repl import cleanup_repl, create_repl
 
-    KlongPy REPL: See https://t3x.org/klong/klong-ref.txt.html for additional details.
+_READLINE_SPEC = importlib.util.find_spec("readline")
+readline = importlib.import_module("readline") if _READLINE_SPEC else None
 
-"""
 
 def sys_cmd_shell(klong, cmd):
     """
@@ -112,7 +114,7 @@ def sys_cmd_exit(klong, cmd):
 
     """
     print("bye!")
-    sys.exit(0)
+    return ExitRequest(0)
 
 
 def sys_cmd_transcript(klong, cmd):
@@ -174,10 +176,17 @@ success = lambda input: f"{colorama.Fore.GREEN}{input}"
 failure = lambda input: f"{colorama.Fore.RED}{input}"
 
 
+class ExitRequest:
+    def __init__(self, code=0):
+        self.code = 0 if code is None else code
+
+
 async def repl_eval(klong, p, verbose=True):
     try:
         r = klong(p)
-        r = r if r is None else success(kg_write(r, display=False))
+        r = r if r is None else success(kg_write(r, klong._backend, display=False))
+    except SystemExit as exc:
+        return ExitRequest(exc.code)
     except Exception as e:
         r = failure(f"Error: {e.args}")
         if verbose:
@@ -187,12 +196,14 @@ async def repl_eval(klong, p, verbose=True):
     return r
 
 
-def show_repl_header(ipc_addr=None):
+def show_repl_header(backend_name, device_name=None, ipc_addr=None):
     print()
     print(f"{colorama.Fore.GREEN}Welcome to KlongPy REPL v{importlib.metadata.distribution('klongpy').version}")
     print(f"{colorama.Fore.GREEN}Author: Brian Guarraci")
     print(f"{colorama.Fore.GREEN}Web: http://klongpy.org")
-    print(f"{colorama.Fore.YELLOW}]h for help; crtl-d or ]q to quit")
+    device_str = f" ({device_name})" if device_name else ""
+    print(f"{colorama.Fore.CYAN}Backend: {backend_name}{device_str}")
+    print(f"{colorama.Fore.YELLOW}]h for help; Ctrl-D or ]q to quit")
     print()
     if ipc_addr:
         print(f"{colorama.Fore.RED}Running IPC server at {ipc_addr}")
@@ -209,7 +220,7 @@ def run_in_loop(klong_loop, coro):
 
 class ConsoleInputHandler:
     @staticmethod
-    async def input_producer(console_loop, klong_loop, klong, verbose=False):
+    async def input_producer(console_loop, klong_loop, klong, verbose=False, exit_state=None):
         sys_cmds = create_sys_cmd_functions()
         try:
             while True:
@@ -225,13 +236,29 @@ class ConsoleInputHandler:
                             continue
                     else:
                         r = run_in_loop(klong_loop, repl_eval(klong, s, verbose=verbose))
+                    if isinstance(r, ExitRequest):
+                        if exit_state is not None:
+                            exit_state["code"] = r.code
+                        break
                     if r is not None:
                         print(r)
                 except EOFError:
                     print("\rbye!")
                     break
                 except KeyboardInterrupt:
-                    print(failure("\nkg: error: interrupted"))
+                    buf = ""
+                    if readline is not None:
+                        try:
+                            buf = readline.get_line_buffer()
+                        except Exception:
+                            buf = ""
+                    if buf:
+                        print()
+                        continue
+                    print("\rbye!")
+                    if exit_state is not None:
+                        exit_state["code"] = 130
+                    break
                 except Exception as e:
                     print(failure(f"Error: {e.args}"))
                     import traceback
@@ -241,65 +268,24 @@ class ConsoleInputHandler:
 
 
 async def run_in_klong(klong, s):
-    return klong(s)
+    try:
+        return klong(s)
+    except SystemExit as exc:
+        return ExitRequest(exc.code)
 
 
 def run_file(klong_loop, klong, fname, verbose=False):
+    # Add script directory to sys.path so .py/.pyf imports resolve sibling modules
+    script_dir = os.path.dirname(os.path.abspath(fname))
+    if script_dir not in sys.path:
+        sys.path.insert(0, script_dir)
     with open(fname, "r") as f:
         content = f.read()
-    run_in_loop(klong_loop, run_in_klong(klong, content))
-
-
-def start_loop(loop, stop_event):
-    asyncio.set_event_loop(loop)
-    loop.run_until_complete(stop_event.wait())
+    return run_in_loop(klong_loop, run_in_klong(klong, content))
 
 
-def setup_async_loop(start_loop_func, debug=False, slow_callback_duration=86400) -> asyncio.AbstractEventLoop:
-    loop = asyncio.new_event_loop()
-    loop.slow_callback_duration = slow_callback_duration
-    if debug:
-        loop.set_debug(True)
-    stop_event = asyncio.Event()
-    thread = threading.Thread(target=lambda l=loop,e=stop_event: start_loop_func(l,e), args=(loop,), daemon=True)
-    thread.start()
-    return loop, thread, stop_event
-
-
-def cleanup_async_loop(loop: asyncio.AbstractEventLoop, loop_thread, stop_event, debug=True, name=None) -> None:
-
-    if loop.is_closed():
-        return
-
-    loop.call_soon_threadsafe(stop_event.set)
-    loop_thread.join()
-
-    pending_tasks = asyncio.all_tasks(loop=loop)
-    if len(pending_tasks) > 0:
-        if name:
-            print(f"WARNING: pending tasks in {name} loop")
-        print(f"cancelling {len(pending_tasks)} pending tasks...")
-        for task in pending_tasks:
-            loop.call_soon_threadsafe(task.cancel)
-        # wait for all tasks to be cancelled but we can't use run_until_complete because the loop is already running
-        while len(asyncio.all_tasks(loop=loop)) > 0:
-            time.sleep(0)
-
-    loop.stop()
-
-    if not loop.is_closed():
-        loop.close()
-
-
-def append_pkg_resource_path_KLONGPATH():
-    with importlib.resources.as_file(importlib.resources.files('klongpy')) as pkg_path:
-        pkg_lib_path = os.path.join(pkg_path, "lib")
-        klongpath = os.environ.get("KLONGPATH", ".:lib")
-        klongpath = f"{klongpath}:{pkg_lib_path}" if klongpath else str(pkg_lib_path)
-        os.environ["KLONGPATH"] = klongpath
-
-
-if __name__ == "__main__":
+def main():
+    """Main entry point for the KlongPy REPL."""
     if '--' in sys.argv:
         index = sys.argv.index('--')
         main_args = sys.argv[:index]
@@ -318,37 +304,49 @@ if __name__ == "__main__":
     parser.add_argument('-t', '--test', help='test program from file')
     parser.add_argument('-v', '--verbose', help='enable verbose output', action="store_true")
     parser.add_argument('-d', '--debug', help='enable debug mode', action="store_true")
+    parser.add_argument('--backend', help='set array backend', type=str.lower, choices=list_backends())
+    parser.add_argument('--device', help='set backend device (torch only)', type=str)
     parser.add_argument('filename', nargs='?', help='filename to be run if no flags are specified')
 
     args = parser.parse_args(main_args[1:])
 
+    # Default to torch backend if available and not explicitly set
+    if args.backend is None:
+        available_backends = list_backends()
+        if 'torch' in available_backends:
+            args.backend = 'torch'
+
     if args.debug:
         print("args: ", args)
 
     if args.expr:
-        print(KlongInterpreter()(args.expr))
-        exit()
-
-    klong = KlongInterpreter()
-
-    io_loop, io_loop_thread, io_stop_event = setup_async_loop(start_loop, debug=args.debug)
-    klong_loop, klong_loop_thread, klong_stop_event = setup_async_loop(start_loop, debug=args.debug)
-
-    shutdown_event = CallbackEvent()
+        try:
+            klong = KlongInterpreter(backend=args.backend, device=args.device)
+        except ValueError as exc:
+            parser.error(str(exc))
+        result = klong(args.expr)
+        if result is not None:
+            print(kg_write(result, klong._backend, display=False))
+        return
 
-    append_pkg_resource_path_KLONGPATH()
+    try:
+        klong, loops = create_repl(debug=args.debug, backend=args.backend, device=args.device)
+    except ValueError as exc:
+        parser.error(str(exc))
+    io_loop, _, _, klong_loop, _, _ = loops
+    shutdown_event = klong['.system']['closeEvent']
 
     klong['.helpdb'] = []
-    klong['.system'] = {'ioloop': io_loop, 'klongloop': klong_loop, 'closeEvent': shutdown_event}
     klong['.os.env'] = dict(os.environ)
     klong['.os.argv'] = extras if extras else []
 
     run_repl = False
+    exit_code = None
 
     if args.server:
         r = klong(f".srv({args.server})")
         if r == 0:
-            print(f"Failed to start server")
+            print("Failed to start server")
     elif args.test:
         print(f"Test: {args.test}")
         with open(args.test, "r") as f:
@@ -362,7 +360,9 @@ if __name__ == "__main__":
     if args.filename:
         if args.verbose:
             print(f"Running: {args.filename}")
-        run_file(klong_loop, klong, args.filename, verbose=args.verbose)
+        result = run_file(klong_loop, klong, args.filename, verbose=args.verbose)
+        if isinstance(result, ExitRequest):
+            exit_code = result.code
 
         def gather_io_tasks(io_loop):
             done_event = threading.Event()
@@ -377,7 +377,8 @@ if __name__ == "__main__":
                 done_event.set()
             return done_event
 
-        gather_io_tasks(io_loop).wait()
+        if exit_code is None:
+            gather_io_tasks(io_loop).wait()
     else:
         run_repl = True
 
@@ -390,14 +391,33 @@ if __name__ == "__main__":
         if args.load:
             if args.verbose:
                 print(f"Loading: {args.load}")
-            run_file(klong_loop, klong, args.load, verbose=args.verbose)
-        colorama.init(autoreset=True)
-        show_repl_header(args.server)
-        console_loop.create_task(ConsoleInputHandler.input_producer(console_loop,   klong_loop, klong, args.verbose))
-        console_loop.run_forever()
-        console_loop.close()
+            result = run_file(klong_loop, klong, args.load, verbose=args.verbose)
+            if isinstance(result, ExitRequest):
+                exit_code = result.code
+                run_repl = False
+        if run_repl:
+            exit_state = {"code": None}
+            colorama.init(autoreset=True)
+            backend_name = klong._backend.name
+            device_name = str(klong._backend.device) if hasattr(klong._backend, 'device') else None
+            show_repl_header(backend_name, device_name, args.server)
+            console_loop.create_task(ConsoleInputHandler.input_producer(console_loop, klong_loop, klong, args.verbose, exit_state))
+            try:
+                console_loop.run_forever()
+            except KeyboardInterrupt:
+                exit_state["code"] = 130
+                console_loop.stop()
+            console_loop.close()
+            if exit_state["code"] is not None:
+                exit_code = exit_state["code"]
 
     shutdown_event.trigger()
 
-    cleanup_async_loop(io_loop, io_loop_thread, stop_event=io_stop_event, debug=args.debug, name="io_loop")
-    cleanup_async_loop(klong_loop, klong_loop_thread, stop_event=klong_stop_event, debug=args.debug, name="klong_loop")
+    cleanup_repl(loops, debug=args.debug)
+
+    if exit_code is not None:
+        sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()