klongpy 0.6.8__tar.gz → 0.6.9__tar.gz

{klongpy-0.6.8/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.8
+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)
@@ -332,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.
@@ -388,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.8 → klongpy-0.6.9}/README.md

@@ -288,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.
@@ -344,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.8 → klongpy-0.6.9}/klongpy/core.py

@@ -259,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
 
 

{klongpy-0.6.8 → 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.8 → 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.8 → 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.8 → klongpy-0.6.9}/klongpy/sys_fn.py

@@ -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.8 → 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.8 → 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.8 → 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.8
+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)
@@ -332,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.
@@ -388,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.8 → 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.8 → 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.8 → 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.8',
+    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.8 → 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.8 → 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()
+