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

tests/test_sys_fn_timer.py

@@ -1,133 +0,0 @@
-import asyncio
-import threading
-import unittest
-
-from utils import kg_equal, LoopsBase
-
-from klongpy import KlongInterpreter
-from klongpy.sys_fn import *
-
-
-class TestSysFnTimer(LoopsBase, unittest.TestCase):
-
-    def test_timer_return_0(self):
-        klong = KlongInterpreter()
-        klong['.system'] = {'ioloop': self.ioloop, 'klongloop': self.klongloop}
-
-        async def _test():
-            klong("result::0")
-            klong('cb::{result::3;0}')
-            klong('th::.timer("test";0;cb)')
-
-        async def _test_result():
-            r = klong("result")
-            while r != 3:
-                await asyncio.sleep(0)
-                r = klong("result")
-                self.assertEqual(r,3)
-
-        task = self.klongloop.call_soon_threadsafe(asyncio.create_task, _test())
-        asyncio.run_coroutine_threadsafe(_test_result(), self.klongloop).result()
-
-        task.cancel()
-
-
-    def test_timer_self_terminate(self):
-        klong = KlongInterpreter()
-        klong['.system'] = {'ioloop': self.ioloop, 'klongloop': self.klongloop}
-
-        async def _test():
-            klong("result::0")
-            klong('cb::{result::result+1;result<2}')
-            klong('th::.timer("test";0;cb)')
-
-        async def _test_result():
-            r = klong("result")
-            self.assertTrue(r >= 0 and r < 3)
-            while r != 2:
-                await asyncio.sleep(0)
-                r = klong("result")
-            r = klong(".timerc(th)")
-            self.assertEqual(r,0)
-
-        task = self.klongloop.call_soon_threadsafe(asyncio.create_task, _test())
-        asyncio.run_coroutine_threadsafe(_test_result(), self.klongloop).result()
-        task.cancel()
-
-    def test_timer_return_1_cancel(self):
-        klong = KlongInterpreter()
-        klong['.system'] = {'ioloop': self.ioloop, 'klongloop': self.klongloop}
-
-        async def _test():
-            klong("result::0")
-            klong('cb::{result::result+1;1}')
-            klong('th::.timer("test";0;cb)')
-
-        async def _test_result():
-            r = klong("result")
-            self.assertTrue(r >= 0 and r < 3)
-            while r != 2:
-                await asyncio.sleep(0)
-                r = klong("result")
-            r = klong(".timerc(th)")
-            self.assertEqual(r,1)
-            r = klong(".timerc(th)")
-            self.assertEqual(r,0)
-
-        task = self.klongloop.call_soon_threadsafe(asyncio.create_task, _test())
-        asyncio.run_coroutine_threadsafe(_test_result(), self.klongloop).result()
-        task.cancel()
-
-    def test_timer_1_sec_self_terminate(self):
-        klong = KlongInterpreter()
-        klong['.system'] = {'ioloop': self.ioloop, 'klongloop': self.klongloop}
-
-        start_t = self.klongloop.time()
-
-        async def _test():
-            klong("result::0")
-            klong('cb::{result::result+1;result<2}')
-            klong('th::.timer("test";1;cb)')
-
-        async def _test_result():
-            r = klong("result")
-            self.assertTrue(r >= 0 and r < 3)
-            while r != 2:
-                await asyncio.sleep(0)
-                r = klong("result")
-            delta_t = (self.klongloop.time() - start_t)
-            self.assertTrue(delta_t >= 2)
-            r = klong(".timerc(th)")
-            self.assertEqual(r,0)
-
-        task = self.klongloop.call_soon_threadsafe(asyncio.create_task, _test())
-        asyncio.run_coroutine_threadsafe(_test_result(), self.klongloop).result()
-        task.cancel()
-
-    def test_timer_1_sec_cancel(self):
-        klong = KlongInterpreter()
-        klong['.system'] = {'ioloop': self.ioloop, 'klongloop': self.klongloop}
-
-        start_t = self.klongloop.time()
-
-        async def _test():
-            klong("result::0")
-            klong('cb::{result::result+1;1}')
-            klong('th::.timer("test";1;cb)')
-
-        async def _test_result():
-            r = klong("result")
-            self.assertTrue(r >= 0 and r < 3)
-            while r != 2:
-                await asyncio.sleep(0)
-                r = klong("result")
-            delta_t = (self.klongloop.time() - start_t)
-            self.assertTrue(delta_t >= 2)
-            r = klong(".timerc(th)")
-            self.assertEqual(r,1)
-            r = klong(".timerc(th)")
-            self.assertEqual(r,0)
-
-        task = self.klongloop.call_soon_threadsafe(asyncio.create_task, _test())
-        asyncio.run_coroutine_threadsafe(_test_result(), self.klongloop).result()
-        task.cancel()

tests/test_sys_fn_web.py

@@ -1,50 +0,0 @@
-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()
-

tests/test_util.py

@@ -1,233 +0,0 @@
-import unittest
-from klongpy.core import *
-from utils import die, kg_equal
-
-class TestUtil(unittest.TestCase):
-
-    def test_die(self):
-        with self.assertRaises(RuntimeError):
-            die("test")
-
-    def test_read_shifted_comment(self):
-        t = ':"hello"'
-        i = 0
-        i = read_shifted_comment(t,i+2)
-        self.assertEqual(i,len(t))
-
-    def test_read_shifted_comment_embedded(self):
-        t = 'this is a :"hello" test'
-        i = t.index(':"')+2
-        i = read_shifted_comment(t,i)
-        self.assertEqual(i,t.index(" test"))
-
-    def test_read_shifted_comment_double_quote_embedded(self):
-        t = 'this is a :"hello""world" test'
-        i = t.index(':"')+2
-        i = read_shifted_comment(t,i)
-        self.assertEqual(i,t.index(" test"))
-
-    def test_read_string(self):
-        t = '"hello"'
-        i = 0
-        i,s = read_string(t,i+1)
-        self.assertEqual(i,len(t))
-        self.assertEqual(s,"hello")
-
-    def test_read_substring(self):
-        t = 'this is "hello" test'
-        i = t.index('"')+1
-        i,s = read_string(t,i)
-        self.assertEqual(i,t.index(" test"))
-        self.assertEqual(s,"hello")
-
-    def test_read_quoted_substring(self):
-        t = 'this is "hello""""world" test'
-        i = t.index('"')+1
-        i,s = read_string(t,i)
-        self.assertEqual(i,t.index(" test"))
-        self.assertEqual(s,'hello""world')
-
-    def test_read_double_quoted_substring(self):
-        t = 'this is "hello""""""world" test'
-        i = t.index('"')+1
-        i,s = read_string(t,i)
-        self.assertEqual(i,t.index(" test"))
-        self.assertEqual(s,'hello"""world')
-
-    def test_read_empty_string(self):
-        t = '""'
-        i = 0
-        i,s = read_string(t,i+1)
-        self.assertEqual(i,len(t))
-        self.assertEqual(s,'')
-
-    def test_read_quoted_empty_string(self):
-        t = '""""'
-        i = 0
-        i,s = read_string(t,i+1)
-        self.assertEqual(i,len(t))
-        # TODO: this seems like a bug in kg parsing strings since it starts on i+1
-        self.assertEqual(s,'"')
-
-    def test_read_double_quoted_empty_string(self):
-        t = '""""""'
-        i = 0
-        i,s = read_string(t,i+1)
-        self.assertEqual(i,len(t))
-        # TODO: this seems like a bug in kg parsing strings since it starts on i+1
-        self.assertEqual(s,'""')
-
-
-    def test_read_quoted_embedded_string(self):
-        t = '":["""";1;2]"'
-        i = 0
-        i,s = read_string(t,i+1)
-        self.assertEqual(i,len(t))
-        self.assertEqual(s,':["";1;2]')
-
-    def test_embedded_string(self):
-        t = '"A::""hello, world!"""'
-        i = 0
-        i,s = read_string(t,i+1)
-        self.assertEqual(i,len(t))
-        self.assertEqual(s,'A::"hello, world!"')
-
-    def test_is_list(self):
-        self.assertTrue(is_list([]))
-        self.assertTrue(is_list(np.array([])))
-        self.assertFalse(is_list(()))
-        self.assertFalse(is_list(1))
-        self.assertFalse(is_list(None))
-
-    def test_is_iterable(self):
-        self.assertTrue(is_iterable(""))
-        self.assertTrue(is_iterable(''))
-        self.assertTrue(is_iterable([]))
-        self.assertFalse(is_iterable(None))
-        self.assertFalse(is_iterable(1))
-
-    def test_is_empty(self):
-        self.assertTrue(is_empty(""))
-        self.assertTrue(is_empty(''))
-        self.assertTrue(is_empty([]))
-        self.assertTrue(is_empty(np.array([])))
-        self.assertFalse(is_empty(np.array([1])))
-        self.assertFalse(is_empty([1]))
-        self.assertFalse(is_empty(None))
-        self.assertFalse(is_empty(1))
-
-    def test_to_list(self):
-        self.assertTrue(isinstance(to_list([]), list))
-        self.assertEqual(to_list([]), [])
-        self.assertTrue(isinstance(to_list(1), list))
-        self.assertEqual(to_list([1]), [1])
-        self.assertTrue(isinstance(to_list(np.array([])), list))
-        self.assertEqual(to_list(np.array([])), [])
-        self.assertTrue(isinstance(to_list(np.array([1])), list))
-        self.assertEqual(to_list(np.array([1])), np.array([1]))
-
-    def test_is_float(self, fn=is_float):
-        self.assertFalse(fn(None))
-        self.assertFalse(fn([]))
-        self.assertFalse(fn([1]))
-        self.assertFalse(fn({}))
-        self.assertFalse(fn(""))
-        self.assertFalse(fn("a"))
-        self.assertFalse(fn("0"))
-        self.assertFalse(fn("1"))
-        self.assertFalse(fn("0.0"))
-        self.assertFalse(fn("1.0"))
-        self.assertTrue(fn(0))
-        self.assertTrue(fn(1))
-        self.assertTrue(fn(-1))
-        self.assertTrue(fn(0.0))
-        self.assertTrue(fn(-0.0))
-        self.assertTrue(fn(1.0))
-        self.assertTrue(fn(-1.0))
-
-    def test_is_int(self, fn=is_integer, allow_floats=False):
-        self.assertFalse(fn(None))
-        self.assertFalse(fn([]))
-        self.assertFalse(fn([1]))
-        self.assertFalse(fn({}))
-        self.assertFalse(fn(""))
-        self.assertFalse(fn("a"))
-        self.assertFalse(fn("0"))
-        self.assertFalse(fn("1"))
-        self.assertFalse(fn("0.0"))# if not allow_floats else self.assertTrue(fn("0.0"))
-        self.assertFalse(fn("1.0"))# if not allow_floats else self.assertTrue(fn("1.0"))
-        self.assertTrue(fn(0))
-        self.assertTrue(fn(1))
-        self.assertTrue(fn(-1))
-        self.assertTrue(fn(0))
-        self.assertTrue(fn(-0))
-        self.assertTrue(fn(1))
-        self.assertTrue(fn(-1))
-
-    def test_is_number(self):
-        self.test_is_float(fn=is_number)
-        self.test_is_int(fn=is_number, allow_floats=True)
-
-    def test_in_map(self):
-        self.assertFalse(in_map(1,None))
-        self.assertFalse(in_map(1,{}))
-        self.assertTrue(in_map(1,{1:2}))
-
-    def test_is_char(self):
-        self.assertFalse(is_char(None))
-        self.assertFalse(is_char(0))
-        self.assertFalse(is_char([]))
-        self.assertFalse(is_char({}))
-        self.assertFalse(is_char(()))
-        self.assertTrue(is_char(KGChar('1')))
-        self.assertTrue(is_char(KGChar("1")))
-        self.assertTrue(is_char(KGChar("-")))
-        self.assertTrue(is_char(KGChar('a')))
-        self.assertTrue(is_char(KGChar("a")))
-        self.assertFalse(is_char("ab"))
-
-    def test_cmatch(self):
-        arr = "abc"
-        self.assertFalse(cmatch(arr, 4, 'a'))
-        [self.assertFalse(cmatch(arr, i, x)) for i,x in enumerate("def")]
-        [self.assertTrue(cmatch(arr, i, x)) for i,x in enumerate(arr)]
-
-    def test_cexpect(self):
-        arr = "abc"
-        with self.assertRaises(UnexpectedChar) as cm:
-            cexpect(arr, 4, 'a')
-        e = cm.exception
-        self.assertEqual(e.args, ('t: abc pos: 4 char: a',))
-        with self.assertRaises(UnexpectedChar):
-            cexpect(arr, 0, 'e')
-        for i,x in enumerate(arr):
-            self.assertEqual(cexpect(arr, i, x), i+1)
-
-    def test_safe_eq(self):
-        self.assertFalse(safe_eq(1,[]))
-        self.assertTrue(safe_eq(1,1))
-
-    def test_merge_projections(self):
-        self.assertEqual(merge_projections([]), [])
-        self.assertEqual(merge_projections([[1]]), [1])
-        self.assertTrue(np.equal(merge_projections([[10,20,30]]), [10,20,30]).all())
-        self.assertTrue(np.equal(merge_projections([[10,None,None],[20,30]]), np.array([10,20,30])).all())
-        self.assertTrue(np.equal(merge_projections([[10,None,None],[20,None],[30]]), np.array([10,20,30])).all())
-
-    def test_is_adverb(self):
-        a = ["'",':\\',":'",':/','/',':~',':*','\\','\\~','\\*']
-        for x in a:
-            self.assertTrue(is_adverb(x))
-        self.assertFalse(is_adverb(":"))
-        self.assertFalse(is_adverb("dog"))
-
-    def test_argsort(self):
-        a = [1,3,4,2]
-        self.assertTrue(kg_equal(kg_argsort(a), [0, 3, 1, 2]))
-        self.assertTrue(kg_equal(kg_argsort(a,descending=True), [2, 1, 3, 0]))
-        a = [[1],[2],[],[3]]
-        self.assertTrue(kg_equal(kg_argsort(a,descending=True), [3, 1, 0, 2]))
-
-
-if __name__ == '__main__':
-  unittest.main()

tests/utils.py

@@ -1,126 +0,0 @@
-import asyncio
-import threading
-import time
-
-import numpy as np
-
-from klongpy import KlongInterpreter
-from klongpy.core import is_list, kg_equal
-
-
-def die(m=None):
-    raise RuntimeError(m)
-
-
-def eval_cmp(expr_str, expected_str, klong=None):
-    """
-    Parse and execute both sides of a test.
-    """
-    klong = klong or KlongInterpreter()
-    expr = klong.prog(expr_str)[1][0]
-    expected = klong.prog(expected_str)[1][0]
-    a = klong.call(expr)
-    b = klong.call(expected)
-    return kg_equal(a,b)
-
-
-def eval_test(a, klong=None):
-    """
-    To get the system going we need a way to test the t(x;y;z) methods before we can parse them.
-    This test bootstraps the testing process via parsing the t() format.
-    """
-    klong = klong or create_test_klong()
-    s = a[2:-1]
-    i,p = klong.prog(s)
-    if i != len(s):
-        return False
-    a = klong.call(p[1])
-    b = klong.call(p[2])
-    if np.isarray(a) and np.isarray(b):
-        c = a == b
-        return not c[np.where(c == False)].any() if np.isarray(c) else c
-    else:
-        return kg_equal(a,b)
-
-
-def create_test_klong():
-    """
-    Create a Klong instance that is similar to the Klong test suite,
-    but modified to fail with die()
-    """
-    klong = KlongInterpreter()
-    klong('err::0;')
-    def fail(x,y,z):
-        print(x,y,z)
-        die()
-    klong['fail'] = fail
-    klong('t::{:[~y~z;fail(x;y;z);[]]}')
-    klong('rnd::{:[x<0;-1;1]*_0.5+#x}')
-    klong('rndn::{rnd(x*10^y)%10^y}')
-    return klong
-
-
-def run_file(x, klong=None):
-    with open(x, "r") as f:
-        klong = klong or KlongInterpreter()
-        return klong, klong(f.read())
-
-
-def rec_fn2(a,b,f):
-    return np.asarray([rec_fn2(x, y, f) for x,y in zip(a,b)], dtype=object) if is_list(a) and is_list(b) else f(a,b)
-
-
-class LoopsBase:
-    def setUp(self):
-        # print("\nRunning test:", self._testMethodName)
-
-        self.ioloop = asyncio.new_event_loop()
-        self.ioloop.set_debug(True)
-        self.ioloop_started = threading.Event()
-
-        self.ioloop_thread = threading.Thread(target=self.start_ioloop)
-        self.ioloop_thread.start()
-        self.ioloop_started.wait()
-        self.assertTrue(self.ioloop.is_running())
-
-        self.klongloop = asyncio.new_event_loop()
-        self.klongloop.set_debug(True)
-        self.klongloop_started = threading.Event()
-
-        self.klongloop_thread = threading.Thread(target=self.start_klongloop)
-        self.klongloop_thread.start()
-        self.klongloop_started.wait()
-        self.assertTrue(self.klongloop.is_running())
-
-    def tearDown(self):
-        while len(asyncio.all_tasks(loop=self.ioloop)) > 0:
-            time.sleep(0.1)
-        self.ioloop.call_soon_threadsafe(self.ioloop.stop)
-        self.ioloop_thread.join()
-        self.ioloop.close()
-
-        while len(asyncio.all_tasks(loop=self.klongloop)) > 0:
-            time.sleep(0.1)
-        self.klongloop.call_soon_threadsafe(self.klongloop.stop)
-        self.klongloop_thread.join()
-        self.klongloop.close()
-
-    def start_ioloop(self):
-        asyncio.set_event_loop(self.ioloop)
-        self.ioloop.call_soon(self.ioloop_start_signal) 
-        self.ioloop.run_forever()
-
-    def ioloop_start_signal(self):
-        """Coroutine to set the event once the loop has started."""
-        self.assertTrue(self.ioloop.is_running())
-        self.ioloop_started.set()
-
-    def start_klongloop(self):
-        asyncio.set_event_loop(self.klongloop)
-        self.klongloop.call_soon(self.klongloop_start_signal) 
-        self.klongloop.run_forever()
-
-    def klongloop_start_signal(self):
-        """Coroutine to set the event once the loop has started."""
-        self.assertTrue(self.klongloop.is_running())
-        self.klongloop_started.set()