klongpy 0.6.7__tar.gz → 0.6.9__tar.gz

{klongpy-0.6.7/klongpy.egg-info → klongpy-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: klongpy
-Version: 0.6.7
+Version: 0.6.9
 Summary: High-Performance Klong array language with rich Python integration.
 Author: Brian Guarraci
 License: MIT
@@ -32,15 +32,25 @@ Provides-Extra: web
 Requires-Dist: aiohttp==3.9.4; extra == "web"
 Provides-Extra: db
 Requires-Dist: pandas==2.2.2; extra == "db"
-Requires-Dist: duckdb==1.0.0; extra == "db"
+Requires-Dist: duckdb==1.3.0; extra == "db"
 Provides-Extra: ws
 Requires-Dist: websockets==12.0; extra == "ws"
 Provides-Extra: full
 Requires-Dist: colorama==0.4.6; extra == "full"
 Requires-Dist: aiohttp==3.9.4; extra == "full"
 Requires-Dist: pandas==2.2.2; extra == "full"
-Requires-Dist: duckdb==1.0.0; extra == "full"
+Requires-Dist: duckdb==1.3.0; extra == "full"
 Requires-Dist: websockets==12.0; extra == "full"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 ![Unit Tests](https://github.com/briangu/klongpy/workflows/Unit%20Tests/badge.svg)
@@ -54,8 +64,6 @@ Requires-Dist: websockets==12.0; extra == "full"
 [![Downloads](https://static.pepy.tech/badge/klongpy/month)](https://pepy.tech/project/klongpy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/klongpy.svg?style=social&label=Follow%20%40KlongPy)](https://twitter.com/klongpy)
-
 # KlongPy: High-Performance Array Programming in Python
 
 KlongPy is a Python adaptation of the [Klong](https://t3x.org/klong) [array language](https://en.wikipedia.org/wiki/Array_programming), known for its high-performance vectorized operations that leverage the power of NumPy. Embracing a "batteries included" philosophy, KlongPy combines built-in modules with Python's expansive ecosystem, facilitating rapid application development with Klong's succinct syntax.
@@ -334,6 +342,31 @@ $ curl http://localhost:8888
 ['Hello, Klong World! ' 0 1 2 3 4 5 6 7 8 9]
 ```
 
+You can also spin up this server directly inside the REPL:
+
+```kgpy
+?> .py("klongpy.web")
+?> data::!10
+?> index::{x; "Hello, Klong World! ", data}
+?> get:::{}; get,"/",index
+?> post:::{}
+?> h::.web(8888;get;post)
+```
+
+And from another terminal:
+
+```bash
+$ curl http://localhost:8888
+['Hello, Klong World! ' 0 1 2 3 4 5 6 7 8 9]
+```
+
+Stop the server with:
+
+```kgpy
+?> .webc(h)
+1
+```
+
 ## Conclusion
 
 These examples are designed to illustrate the "batteries included" approach, ease of use and diverse applications of KlongPy, making it a versatile choice for various programming needs.
@@ -390,6 +423,7 @@ KlongPy is effectively a superset of the Klong language, but has some key differ
 * Infinite precision: The main difference in this implementation of Klong is the lack of infinite precision.  By using NumPy we are restricted to doubles.
 * Python integration: Most notably, the ".py" command allows direct import of Python modules into the current Klong context.
 * KlongPy aims to be more "batteries included" approach to modules and contains additional features such as IPC, Web service, Websockets, etc.
+* For array operations, KlongPy matches the shape of array arguments differently. Compare the results of an expression like `[1 2]+[[3 4][5 6]]` which in Klong produces `[[4 5] [7 8]]` but in KlongPy produces `[[4 6] [6 8]]`.
 
 # Related
 

{klongpy-0.6.7 → klongpy-0.6.9}/README.md

@@ -10,8 +10,6 @@
 [![Downloads](https://static.pepy.tech/badge/klongpy/month)](https://pepy.tech/project/klongpy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/klongpy.svg?style=social&label=Follow%20%40KlongPy)](https://twitter.com/klongpy)
-
 # KlongPy: High-Performance Array Programming in Python
 
 KlongPy is a Python adaptation of the [Klong](https://t3x.org/klong) [array language](https://en.wikipedia.org/wiki/Array_programming), known for its high-performance vectorized operations that leverage the power of NumPy. Embracing a "batteries included" philosophy, KlongPy combines built-in modules with Python's expansive ecosystem, facilitating rapid application development with Klong's succinct syntax.
@@ -290,6 +288,31 @@ $ curl http://localhost:8888
 ['Hello, Klong World! ' 0 1 2 3 4 5 6 7 8 9]
 ```
 
+You can also spin up this server directly inside the REPL:
+
+```kgpy
+?> .py("klongpy.web")
+?> data::!10
+?> index::{x; "Hello, Klong World! ", data}
+?> get:::{}; get,"/",index
+?> post:::{}
+?> h::.web(8888;get;post)
+```
+
+And from another terminal:
+
+```bash
+$ curl http://localhost:8888
+['Hello, Klong World! ' 0 1 2 3 4 5 6 7 8 9]
+```
+
+Stop the server with:
+
+```kgpy
+?> .webc(h)
+1
+```
+
 ## Conclusion
 
 These examples are designed to illustrate the "batteries included" approach, ease of use and diverse applications of KlongPy, making it a versatile choice for various programming needs.
@@ -346,6 +369,7 @@ KlongPy is effectively a superset of the Klong language, but has some key differ
 * Infinite precision: The main difference in this implementation of Klong is the lack of infinite precision.  By using NumPy we are restricted to doubles.
 * Python integration: Most notably, the ".py" command allows direct import of Python modules into the current Klong context.
 * KlongPy aims to be more "batteries included" approach to modules and contains additional features such as IPC, Web service, Websockets, etc.
+* For array operations, KlongPy matches the shape of array arguments differently. Compare the results of an expression like `[1 2]+[[3 4][5 6]]` which in Klong produces `[[4 5] [7 8]]` but in KlongPy produces `[[4 6] [6 8]]`.
 
 # Related
 

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy/core.py

@@ -87,6 +87,12 @@ class KGCond(list):
     pass
 
 
+def safe_inspect(fn, follow_wrapped=True):
+    try:
+        return inspect.signature(fn, follow_wrapped=follow_wrapped).parameters
+    except ValueError:
+        return {"args":[]}
+
 class KGLambda:
     """
     KGLambda wraps a lambda and make it available to Klong, allowing for direct
@@ -109,7 +115,7 @@ class KGLambda:
     """
     def __init__(self, fn, args=None, provide_klong=False, wildcard=False):
         self.fn = fn
-        params = args or inspect.signature(self.fn, follow_wrapped=True).parameters
+        params = args or safe_inspect(fn)
         self.args = [reserved_fn_symbol_map[x] for x in reserved_fn_args if x in params]
         self._provide_klong = provide_klong or 'klong' in params
         self._wildcard = wildcard
@@ -253,17 +259,19 @@ def kg_asarray(a):
     arr : ndarray
         The converted input data as a NumPy array, where all elements and sub-arrays are also NumPy arrays.
     """
+    if isinstance(a, str):
+        return str_to_chr_arr(a)
     try:
         arr = np.asarray(a)
         if arr.dtype.kind not in ['O','i','f']:
             raise ValueError
     except (np.VisibleDeprecationWarning, ValueError):
         try:
-            arr = np.asarray(a,dtype=object)
+            arr = np.asarray(a, dtype=object)
         except ValueError:
             arr = [x.tolist() if np.isarray(x) else x for x in a]
-            arr = np.asarray(arr,dtype=object)
-        arr = np.asarray([kg_asarray(x) if isinstance(x,list) else x for x in arr],dtype=object)
+            arr = np.asarray(arr, dtype=object)
+        arr = np.asarray([kg_asarray(x) if isinstance(x, list) else x for x in arr], dtype=object)
     return arr
 
 
@@ -636,6 +644,7 @@ def read_cond(klong, t, i=0):
         i = cexpect(t, i, ';')
         i,n = klong._expr(t, i, ignore_newline=True)
         r.append(n)
+        i = skip(t,i,ignore_newline=True)
         i = cexpect(t, i, ']')
     return i, KGCond(r)
 
@@ -694,9 +703,9 @@ def kg_read(t, i=0, read_neg=False, ignore_newline=False, module=None, list_leve
     if i >= len(t):
         return i, None
     a = t[i]
-    if a in ['\n', ';']:
-        return i+1,';'
-    elif a in ['(',')','{','}',']']:
+    if a == '\n':
+        a = ';' # convert newlines to semicolons
+    if a in [';','(',')','{','}',']']:
         return i+1,a
     elif cmatch2(t, i, '0', 'c'):
         return read_char(t, i)

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy/dyads.py

@@ -181,7 +181,11 @@ def eval_dyad_at_index(klong, a, b):
         j = False
     else:
         r = a
-    return "".join(r) if j else r
+    if j:
+        if np.isarray(r) and r.ndim > 1:
+            return np.asarray(["".join(x) for x in r], dtype=object)
+        return "".join(r)
+    return r
 
 
 def eval_dyad_define(klong, n, v):
@@ -401,9 +405,11 @@ def _e_dyad_format2(a, b):
     """
     Unravel the broadcasting of a and b and apply __e_dyad_format2
     """
+    if is_list(a) and is_list(b):
+        return kg_asarray([vec_fn2(x, y, _e_dyad_format2) for x, y in zip(to_list(a), to_list(b))])
     if np.isarray(a) and np.isarray(b):
-        return np.asarray([vec_fn2(x,y,_e_dyad_format2) for x,y in zip(a,b)])
-    return __e_dyad_format2(a,b)
+        return np.asarray([vec_fn2(x, y, _e_dyad_format2) for x, y in zip(a, b)])
+    return __e_dyad_format2(a, b)
 
 def eval_dyad_format2(a, b):
     """
@@ -832,7 +838,11 @@ def eval_dyad_reshape(a, b):
                 r = np.concatenate((np.tile(b,ns), b[:a - b.shape[0]*ns[0]]))
         else:
             r = np.full((a,), b)
-    return "".join(r) if j else r
+    if j:
+        if np.isarray(r) and r.ndim > 1:
+            return np.asarray(["".join(x) for x in r], dtype=object)
+        return "".join(r)
+    return r
 
 
 def eval_dyad_rotate(a, b):

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy/interpreter.py

@@ -119,7 +119,7 @@ class KlongContext():
                         if dk.startswith(tk):
                             return True
         return False
-    
+
     def __iter__(self):
         seen = set()
         for d in self._context:
@@ -358,6 +358,7 @@ class KlongInterpreter():
         if safe_eq(a, '{'): # read fn
             i,a = self.prog(t, i, ignore_newline=True)
             a = a[0] if len(a) == 1 else a
+            i = skip(t, i, ignore_newline=True)
             i = cexpect(t, i, '}')
             arity = get_fn_arity(a)
             if cmatch(t, i, '(') or cmatch2(t,i,':','('):
@@ -416,6 +417,7 @@ class KlongInterpreter():
             if safe_eq(aa, '{'): # read fn
                 i,aa = self.prog(t, i, ignore_newline=True)
                 aa = aa[0] if len(aa) == 1 else aa
+                i = skip(t, i, ignore_newline=True)
                 i = cexpect(t, i, '}')
                 arity = get_fn_arity(aa)
                 if cmatch(t, i, '(') or cmatch2(t,i,':','('):
@@ -433,6 +435,8 @@ class KlongInterpreter():
                 i, aaa = self._expr(t, i, ignore_newline=ignore_newline)
                 a = KGFn(aa, [a, aaa], arity=2)
             ii, aa = kg_read(t, i, ignore_newline=ignore_newline, module=self.current_module())
+        if ignore_newline and safe_eq(a, '\n'):
+            i = skip(t, i, ignore_newline=True)
         return i, a
 
     def prog(self, t, i=0, ignore_newline=False):
@@ -481,12 +485,12 @@ class KlongInterpreter():
         - f_args is the list of arguments provided to the function during the current invocation.
         - f.args (if f is an instance of KGFn) represents predefined arguments associated with the function.
         These are arguments that are already set by virtue of the function being a projection of another function.
-        - During the resolution process, if the function f is a KGFn with predefined arguments (projections), 
+        - During the resolution process, if the function f is a KGFn with predefined arguments (projections),
         these arguments are appended to the f_args list.
-        - The resolution process ensures that if there are placeholders in the predefined arguments, they are 
+        - The resolution process ensures that if there are placeholders in the predefined arguments, they are
         filled in with values from the provided arguments. However, if the function itself is being projected,
         f_args can still contain a None indicating an empty projection slot.
-        - By the end of the resolution, f_args contains the arguments that will be passed to the function for 
+        - By the end of the resolution, f_args contains the arguments that will be passed to the function for
         evaluation. It is possible for f_args to finally contain None if the function is itself being projected.
         - If `f.a` (the main function or symbol) resolves to another function `_f`, it might indicate a higher-order function scenario.
         - In such a case, `f_args` supplies a function as an argument to `f.a`.

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy/lib/help.kg

@@ -30,8 +30,8 @@ op.db::[
  [" a:$b" "Form"
   "b=string; convert 'b' to an object of the same form (type) as 'a'"]
  [" $a" "Format" "convert 'a' to a string representing the value of 'a'"]
- [" a$b" "Format2"
-  "a=real; Format 'b', pad with 'a' blanks or to align to x.y digits"]
+[" a$b" "Format2"
+ "a=real|list; when both operands are lists, apply pairwise. Format 'b', pad with 'a' blanks or to align to x.y digits"]
  [" >a" "Grade-Down"
   "a=vector; vector of indices of elements of 'a' in ascending order"]
  [" <a" "Grade-Up"

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy/monads.py

@@ -74,7 +74,8 @@ def eval_monad_expand_where(a):
                   &[0 1 0 1 0]  -->   [1 3]
 
     """
-    return np.concatenate([np.zeros(x, dtype=int) + i for i,x in enumerate(a if is_list(a) else [a])])
+    arr = a if is_list(a) else [a]
+    return np.repeat(np.arange(len(arr)), arr)
 
 
 def eval_monad_first(a):
@@ -163,7 +164,7 @@ def eval_monad_grade_up(a):
                     >[[1] [2] [3]]  -->  [2 1 0]
 
     """
-    return kg_argsort(str_to_chr_arr(a) if isinstance(a,str) else a)
+    return kg_argsort(kg_asarray(a))
 
 
 def eval_monad_grade_down(a):
@@ -174,7 +175,7 @@ def eval_monad_grade_down(a):
         See [Grade-Up].
 
     """
-    return kg_argsort(str_to_chr_arr(a) if isinstance(a,str) else a, descending=True)
+    return kg_argsort(kg_asarray(a), descending=True)
 
 
 def eval_monad_groupby(a):
@@ -194,12 +195,12 @@ def eval_monad_groupby(a):
                   ="hello foo"  -->  [[0] [1] [2 3] [4 7 8] [5] [6]]
 
     """
-    q = np.asarray(str_to_chr_arr(a) if isinstance(a, str) else a)
-    if len(q) == 0:
-        return q
-    a = q.argsort()
-    r = np.split(a, np.where(q[a][1:] != q[a][:-1])[0] + 1)
-    return np.asarray(r, dtype=object)
+    arr = kg_asarray(a)
+    if arr.size == 0:
+        return arr
+    vals, inverse = np.unique(arr, return_inverse=True)
+    groups = [np.where(inverse == i)[0] for i in range(len(vals))]
+    return kg_asarray(groups)
 
 
 def eval_monad_list(a):
@@ -217,7 +218,7 @@ def eval_monad_list(a):
     if isinstance(a, KGChar):
         return str(a)
     if isinstance(a, KGSym):
-        np.asarray([a],dtype=object) # np interpets ':foo" as ':fo"
+        return np.asarray([a],dtype=object) # np interprets ':foo" as ':fo"
     return np.asarray([a])
 
 

klongpy-0.6.9/klongpy/repl.py

@@ -0,0 +1,73 @@
+import asyncio
+import threading
+import time
+import os
+import importlib.resources
+
+from . import KlongInterpreter
+from .utils import CallbackEvent
+
+
+def start_loop(loop: asyncio.AbstractEventLoop, stop_event: asyncio.Event) -> None:
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(stop_event.wait())
+
+
+def setup_async_loop(debug: bool = False, slow_callback_duration: float = 86400.0):
+    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=start_loop, args=(loop, stop_event), daemon=True)
+    thread.start()
+    return loop, thread, stop_event
+
+
+def cleanup_async_loop(loop: asyncio.AbstractEventLoop, loop_thread: threading.Thread, stop_event: asyncio.Event, debug: bool = False, name: str | None = 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")
+        for task in pending_tasks:
+            loop.call_soon_threadsafe(task.cancel)
+        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() -> None:
+    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
+
+
+def create_repl(debug: bool = False):
+    io_loop, io_thread, io_stop = setup_async_loop(debug=debug)
+    klong_loop, klong_thread, klong_stop = setup_async_loop(debug=debug)
+
+    append_pkg_resource_path_KLONGPATH()
+
+    klong = KlongInterpreter()
+    shutdown_event = CallbackEvent()
+    klong['.system'] = {'ioloop': io_loop, 'klongloop': klong_loop, 'closeEvent': shutdown_event}
+
+    return klong, (io_loop, io_thread, io_stop, klong_loop, klong_thread, klong_stop)
+
+
+def cleanup_repl(loops, debug: bool = False) -> None:
+    io_loop, io_thread, io_stop, klong_loop, klong_thread, klong_stop = loops
+    cleanup_async_loop(io_loop, io_thread, io_stop, debug=debug, name='io_loop')
+    cleanup_async_loop(klong_loop, klong_thread, klong_stop, debug=debug, name='klong_loop')

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy/sys_fn.py

@@ -13,7 +13,7 @@ import numpy
 
 from .core import (KGChannel, KGChannelDir, KGLambda, KGSym, KlongException,
                    is_dict, is_empty, is_list, kg_asarray, kg_read, kg_write, np,
-                   reserved_fn_args, reserved_fn_symbol_map, safe_eq)
+                   reserved_fn_args, reserved_fn_symbol_map, safe_eq, safe_inspect)
 
 
 def eval_sys_append_channel(x):
@@ -341,7 +341,7 @@ def _handle_import(item):
             if n_args <= len(reserved_fn_args):
                 item = KGLambda(item, args=reserved_fn_args[:n_args])
         else:
-            args = inspect.signature(item, follow_wrapped=True).parameters
+            args = safe_inspect(item, follow_wrapped=True)
             if 'args' in args:
                 item = KGLambda(item, args=None, wildcard=True)
                 n_args = 3
@@ -405,7 +405,7 @@ def _import_module(klong, x, from_set=None):
             module = import_module_from_sys(x)
 
         export_items = module.__dict__.get("klongpy_exports") or module.__dict__
-        ffn = lambda p: p[0] in from_set if from_set is not None else lambda p: not p[0].startswith("__")
+        ffn = (lambda p: p[0] in from_set) if from_set is not None else (lambda p: not p[0].startswith("__"))
 
         ctx = klong._context.pop()
         try:

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy/sys_fn_ipc.py

@@ -919,7 +919,6 @@ def eval_sys_fn_create_ipc_server(klong, x):
         if "x" is 0, then the server is closed and existing client connections are dropped.
 
     """
-    global _ipc_tcp_server
     x = str(x)
     parts = x.split(":")
     bind = parts[0] if len(parts) > 1 else None

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy/web/sys_fn_web.py

@@ -1,5 +1,7 @@
 import logging
 import sys
+import asyncio
+import concurrent.futures
 
 from aiohttp import web
 
@@ -113,7 +115,17 @@ def eval_sys_fn_create_web_server(klong, x, y, z):
         site = web.TCPSite(runner, bind, port)
         await site.start()
 
-    server_task = klong['.system']['ioloop'].create_task(start_server())
+    # create the server task in the ioloop thread and capture the task handle
+    server_loop = klong['.system']['ioloop']
+    task_future = concurrent.futures.Future()
+
+    def _start():
+        task = asyncio.create_task(start_server())
+        task_future.set_result(task)
+
+    server_loop.call_soon_threadsafe(_start)
+    server_task = task_future.result()
+
     return WebServerHandle(bind, port, runner, server_task)
 
 
@@ -129,7 +141,7 @@ def eval_sys_fn_shutdown_web_server(klong, x):
         x = x.a.fn
         if isinstance(x, WebServerHandle) and x.runner is not None:
             print("shutting down web server")
-            klong['.system']['ioloop'].run_until_complete(x.shutdown())
+            asyncio.run_coroutine_threadsafe(x.shutdown(), klong['.system']['ioloop']).result()
             return 1
     return 0
 

{klongpy-0.6.7 → klongpy-0.6.9/klongpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: klongpy
-Version: 0.6.7
+Version: 0.6.9
 Summary: High-Performance Klong array language with rich Python integration.
 Author: Brian Guarraci
 License: MIT
@@ -32,15 +32,25 @@ Provides-Extra: web
 Requires-Dist: aiohttp==3.9.4; extra == "web"
 Provides-Extra: db
 Requires-Dist: pandas==2.2.2; extra == "db"
-Requires-Dist: duckdb==1.0.0; extra == "db"
+Requires-Dist: duckdb==1.3.0; extra == "db"
 Provides-Extra: ws
 Requires-Dist: websockets==12.0; extra == "ws"
 Provides-Extra: full
 Requires-Dist: colorama==0.4.6; extra == "full"
 Requires-Dist: aiohttp==3.9.4; extra == "full"
 Requires-Dist: pandas==2.2.2; extra == "full"
-Requires-Dist: duckdb==1.0.0; extra == "full"
+Requires-Dist: duckdb==1.3.0; extra == "full"
 Requires-Dist: websockets==12.0; extra == "full"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 ![Unit Tests](https://github.com/briangu/klongpy/workflows/Unit%20Tests/badge.svg)
@@ -54,8 +64,6 @@ Requires-Dist: websockets==12.0; extra == "full"
 [![Downloads](https://static.pepy.tech/badge/klongpy/month)](https://pepy.tech/project/klongpy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/klongpy.svg?style=social&label=Follow%20%40KlongPy)](https://twitter.com/klongpy)
-
 # KlongPy: High-Performance Array Programming in Python
 
 KlongPy is a Python adaptation of the [Klong](https://t3x.org/klong) [array language](https://en.wikipedia.org/wiki/Array_programming), known for its high-performance vectorized operations that leverage the power of NumPy. Embracing a "batteries included" philosophy, KlongPy combines built-in modules with Python's expansive ecosystem, facilitating rapid application development with Klong's succinct syntax.
@@ -334,6 +342,31 @@ $ curl http://localhost:8888
 ['Hello, Klong World! ' 0 1 2 3 4 5 6 7 8 9]
 ```
 
+You can also spin up this server directly inside the REPL:
+
+```kgpy
+?> .py("klongpy.web")
+?> data::!10
+?> index::{x; "Hello, Klong World! ", data}
+?> get:::{}; get,"/",index
+?> post:::{}
+?> h::.web(8888;get;post)
+```
+
+And from another terminal:
+
+```bash
+$ curl http://localhost:8888
+['Hello, Klong World! ' 0 1 2 3 4 5 6 7 8 9]
+```
+
+Stop the server with:
+
+```kgpy
+?> .webc(h)
+1
+```
+
 ## Conclusion
 
 These examples are designed to illustrate the "batteries included" approach, ease of use and diverse applications of KlongPy, making it a versatile choice for various programming needs.
@@ -390,6 +423,7 @@ KlongPy is effectively a superset of the Klong language, but has some key differ
 * Infinite precision: The main difference in this implementation of Klong is the lack of infinite precision.  By using NumPy we are restricted to doubles.
 * Python integration: Most notably, the ".py" command allows direct import of Python modules into the current Klong context.
 * KlongPy aims to be more "batteries included" approach to modules and contains additional features such as IPC, Web service, Websockets, etc.
+* For array operations, KlongPy matches the shape of array arguments differently. Compare the results of an expression like `[1 2]+[[3 4][5 6]]` which in Klong produces `[[4 5] [7 8]]` but in KlongPy produces `[[4 6] [6 8]]`.
 
 # Related
 

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ klongpy/core.py
 klongpy/dyads.py
 klongpy/interpreter.py
 klongpy/monads.py
+klongpy/repl.py
 klongpy/sys_fn.py
 klongpy/sys_fn_ipc.py
 klongpy/sys_fn_timer.py
@@ -60,18 +61,22 @@ tests/perf_sys_fn_db.py
 tests/perf_vector.py
 tests/test_accel.py
 tests/test_df_cache.py
+tests/test_eval_monad_list.py
 tests/test_examples.py
 tests/test_extra_suite.py
 tests/test_file_cache.py
 tests/test_interop.py
+tests/test_kg_asarray.py
 tests/test_kgtests.py
 tests/test_known_bugs.py
 tests/test_prog.py
+tests/test_reshape_strings.py
 tests/test_suite.py
 tests/test_suite_file.py
 tests/test_sys_fn.py
 tests/test_sys_fn_db.py
 tests/test_sys_fn_ipc.py
 tests/test_sys_fn_timer.py
+tests/test_sys_fn_web.py
 tests/test_util.py
 tests/utils.py

{klongpy-0.6.7 → klongpy-0.6.9}/klongpy.egg-info/requires.txt

@@ -20,13 +20,13 @@ cupy
 
 [db]
 pandas==2.2.2
-duckdb==1.0.0
+duckdb==1.3.0
 
 [full]
 colorama==0.4.6
 aiohttp==3.9.4
 pandas==2.2.2
-duckdb==1.0.0
+duckdb==1.3.0
 websockets==12.0
 
 [repl]

{klongpy-0.6.7 → klongpy-0.6.9}/setup.py

@@ -17,7 +17,7 @@ extra_requires = {
         'rocm-4-3': ["cupy-rocm-4-3"],
         'repl': ["colorama==0.4.6"],
         'web': ["aiohttp==3.9.4"],
-        'db': ["pandas==2.2.2","duckdb==1.0.0"],
+        'db': ["pandas==2.2.2","duckdb==1.3.0"],
         'ws': ["websockets==12.0"],
     }
 
@@ -27,7 +27,7 @@ extra_requires['full'] = extra_requires['repl'] + extra_requires['web'] + extra_
 setup(
     name='klongpy',
     packages=find_packages(),
-    version='0.6.7',
+    version='0.6.9',
     description='High-Performance Klong array language with rich Python integration.',
     author='Brian Guarraci',
     license='MIT',

klongpy-0.6.9/tests/test_eval_monad_list.py

@@ -0,0 +1,34 @@
+import unittest
+import numpy as np
+
+from klongpy import KlongInterpreter
+from klongpy.core import KGSym
+from tests.utils import kg_equal
+
+
+class TestEvalMonadList(unittest.TestCase):
+
+    def setUp(self):
+        self.klong = KlongInterpreter()
+
+    def test_int(self):
+        r = self.klong(',1')
+        self.assertTrue(kg_equal(r, np.asarray([1])))
+
+    def test_symbol(self):
+        r = self.klong(',:foo')
+        self.assertTrue(r.dtype == object)
+        self.assertEqual(len(r), 1)
+        self.assertEqual(r[0], KGSym('foo'))
+
+    def test_string(self):
+        r = self.klong(',"xyz"')
+        self.assertTrue(kg_equal(r, np.asarray(['xyz'], dtype=object)))
+
+    def test_list(self):
+        r = self.klong(',[1]')
+        self.assertTrue(kg_equal(r, np.asarray([[1]], dtype=object)))
+
+
+if __name__ == '__main__':
+    unittest.main()

{klongpy-0.6.7 → klongpy-0.6.9}/tests/test_interop.py

@@ -5,7 +5,6 @@ from datetime import datetime
 from utils import *
 
 from klongpy import KlongInterpreter
-from klongpy.core import KGChar
 
 
 class TestPythonInterop(unittest.TestCase):

klongpy-0.6.9/tests/test_kg_asarray.py

@@ -0,0 +1,94 @@
+import unittest
+
+import numpy as np
+
+from klongpy.core import kg_asarray, KGChar, KGSym
+
+
+class TestKGAsArray(unittest.TestCase):
+
+    def test_kg_asarray_scalar_int(self):
+        x = 42
+        arr = kg_asarray(x)
+        assert np.isarray(arr)
+        assert arr.dtype == int
+        assert arr.shape == ()
+        assert arr.item() == 42
+
+    def test_kg_asarray_scalar_float(self):
+        x = 3.14
+        arr = kg_asarray(x)
+        assert np.isarray(arr)
+        assert arr.dtype == float
+        assert arr.item() == 3.14
+
+    def test_kg_asarray_empty_list(self):
+        x = []
+        arr = kg_asarray(x)
+        assert np.isarray(arr)
+        assert arr.dtype == float  # default dtype for empty list
+        assert arr.size == 0
+
+    def test_kg_asarray_string(self):
+        s = "hello"
+        arr = kg_asarray(s)
+        assert np.isarray(arr)
+        assert arr.dtype == object  # assuming KGChar is object dtype
+        assert "".join(arr) == "hello"
+
+    def test_kg_asarray_list_of_ints(self):
+        x = [1, 2, 3]
+        arr = kg_asarray(x)
+        assert np.isarray(arr)
+        assert arr.dtype == int
+        assert np.array_equal(arr, [1, 2, 3])
+
+    def test_kg_asarray_nested_list_uniform(self):
+        x = [[1, 2], [3, 4]]
+        arr = kg_asarray(x)
+        assert np.isarray(arr)
+        assert arr.shape == (2,2)
+        assert arr.dtype == int
+        assert np.array_equal(arr, [[1,2],[3,4]])
+
+    @unittest.skip("what is the expected behavior for this case?")
+    def test_kg_asarray_nested_list_heterogeneous(self):
+        # should embedded strings be expanded to individual characters?
+        x = [[1, 2], "abc", [3.14, None]]
+        arr = kg_asarray(x)
+        assert np.isarray(arr)
+        # Because of heterogeneous data, dtype should be object.
+        assert arr.dtype == object
+        # Check that sub-elements are arrays
+        assert np.isarray(arr[0])
+        assert np.isarray(arr[1])
+        assert np.isarray(arr[2])
+
+    def test_kg_asarray_already_array(self):
+        x = np.array([1, 2, 3])
+        arr = kg_asarray(x)
+        # Should return as-is because already suitable dtype
+        assert arr is x
+
+    def test_kg_asarray_jagged_list(self):
+        x = [[1, 2, 3], [4, 5], [6]]
+        arr = kg_asarray(x)
+        assert np.isarray(arr)
+        # Jagged => object dtype
+        assert arr.dtype == object
+        # Each element should be an array
+        assert all(np.isarray(e) for e in arr)
+        assert np.array_equal(arr[0], [1, 2, 3])
+        assert np.array_equal(arr[1], [4, 5])
+        assert np.array_equal(arr[2], [6])
+
+
+    def benchmark_kg_asarray(self):
+        import timeit
+        x = [[1, 2], [3, 4]]
+        print(timeit.timeit(lambda: kg_asarray(x), number=100_000))
+
+
+if __name__ == "__main__":
+    # run the benchmark
+    TestKGAsArray().benchmark_kg_asarray()

klongpy-0.6.9/tests/test_reshape_strings.py

@@ -0,0 +1,33 @@
+import unittest
+import numpy as np
+
+from klongpy import KlongInterpreter
+from tests.utils import kg_equal
+
+class TestReshapeStrings(unittest.TestCase):
+    def setUp(self):
+        self.klong = KlongInterpreter()
+
+    def test_reshape_string_len1(self):
+        r = self.klong('[2 2]:^"a"')
+        self.assertTrue(kg_equal(r, np.asarray(["aa", "aa"], dtype=object)))
+
+    def test_reshape_string_len2(self):
+        r = self.klong('[2 2]:^"ab"')
+        self.assertTrue(kg_equal(r, np.asarray(["ab", "ab"], dtype=object)))
+
+    def test_reshape_string_len3(self):
+        r = self.klong('[2 2]:^"abc"')
+        self.assertTrue(kg_equal(r, np.asarray(["ab", "ca"], dtype=object)))
+
+    def test_reshape_string_len4(self):
+        r = self.klong('[2 2]:^"abcd"')
+        self.assertTrue(kg_equal(r, np.asarray(["ab", "cd"], dtype=object)))
+
+    def test_reshape_string_larger_shape(self):
+        r = self.klong('[3 3]:^"abcd"')
+        self.assertTrue(kg_equal(r, np.asarray(["abc", "dab", "cda"], dtype=object)))
+
+
+if __name__ == '__main__':
+    unittest.main()

{klongpy-0.6.7 → klongpy-0.6.9}/tests/test_suite.py

@@ -484,6 +484,7 @@ class TestCoreSuite(unittest.TestCase):
         self.assert_eval_cmp('5$1.23', '"1.23 "')
         self.assert_eval_cmp('5$-1.23', '"-1.23"')
         self.assert_eval_cmp('6$-1.23', '"-1.23 "')
+        self.assert_eval_cmp('[1]$[1]', '["1"]')
         self.assert_eval_cmp('(-10)$0', '"         0"')
         self.assert_eval_cmp('(-10)$123', '"       123"')
         self.assert_eval_cmp('(-10)$-123', '"      -123"')

klongpy-0.6.9/tests/test_sys_fn_web.py

@@ -0,0 +1,50 @@
+import asyncio
+import socket
+import unittest
+
+import aiohttp
+
+from klongpy.repl import create_repl, cleanup_repl
+
+
+class TestSysFnWeb(unittest.TestCase):
+    def setUp(self):
+        self.klong, self.loops = create_repl()
+        (self.ioloop, self.ioloop_thread, self.io_stop,
+         self.klongloop, self.klongloop_thread, self.klong_stop) = self.loops
+        self.handle = None
+
+    def tearDown(self):
+        if self.handle is not None and self.handle.task is not None:
+            asyncio.run_coroutine_threadsafe(self.handle.shutdown(), self.ioloop).result()
+        cleanup_repl(self.loops)
+
+    def _free_port(self):
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.bind(("", 0))
+        port = s.getsockname()[1]
+        s.close()
+        return port
+
+    def test_web_server_start_and_stop(self):
+        klong = self.klong
+        port = self._free_port()
+
+        klong('.py("klongpy.web")')
+        klong('index::{x;"hello"}')
+        klong('get:::{}')
+        klong('get,"/",index')
+        klong('post:::{}')
+        handle = klong(f'h::.web({port};get;post)')
+        self.handle = handle
+
+        async def fetch():
+            async with aiohttp.ClientSession() as session:
+                async with session.get(f"http://localhost:{port}/") as resp:
+                    return await resp.text()
+
+        response = asyncio.run_coroutine_threadsafe(fetch(), self.ioloop).result()
+        self.assertEqual(response, "hello")
+
+        asyncio.run_coroutine_threadsafe(handle.shutdown(), self.ioloop).result()
+