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

tests/gen_py_suite.py

@@ -1,77 +0,0 @@
-#!/usr/bin/env python
-
-import re
-
-back_slash_re = re.compile('\\[0-9"]')
-
-def quote_expr(s):
-    s = re.sub(r'(\\[0-9"])', r'\\\1', s)
-    # if '\\"' in s:
-    #     s = s.replace('\\"','\\\\"')
-    if '"' in s and "'" in s:
-        s = s.replace("'", "\\'")
-    elif "'" in s:
-        return f'"{s}"'
-    # if '\"\"\"' in s:
-    #     s = s.replace('\"\"\"', '""\\"')
-    return f"'{s}'"
-
-def get_tests():
-    have_interp = False
-    in_header = True
-    test_names = set()
-    with open("kgtests/language/test_suite.kg", "r") as f:
-        for s in f:
-            s = s.strip()
-            if in_header:
-                if s == ':" Atom "':
-                    in_header = False
-                else:
-                    continue
-            if len(s) == 0 or s == ':[err;[];.p("ok!")]':
-                continue
-            if s.startswith(":\""):
-                have_interp = False
-                if s.startswith(":\"Klong test suite"):
-                    continue
-                x = s[2:-1].strip()
-                name = x.lower().replace(" ","_").replace('-','_').replace('/','_').replace(":", "_")
-                if name in test_names:
-                    name = name + "_2" # only one collision in suite
-                test_names.add(name)
-                print()
-                print(f"    def test_{name}(self):")
-                continue
-            if s.startswith("t("):
-                p = [x.strip() for x in s[2:-1].split(';')][1:]
-                if len(p) == 2:
-                    print(f"        self.assert_eval_cmp({quote_expr(p[0])}, {quote_expr(p[1])}{', klong=klong' if have_interp else ''})")
-                else:
-                    print(f"        self.assert_eval_test({quote_expr(s)}{', klong=klong' if have_interp else ''} )")
-            else:
-                if not have_interp:
-                    have_interp = True
-                    print(f"        klong = create_test_klong()")
-                print(f"        klong({quote_expr(s)})")
-
-
-if __name__ == '__main__':
-    print("""import unittest
-from klongpy import KlongInterpreter
-from utils import *
-
-#
-# DO NOT MODIFY: this file generated by gen_py_suite.py
-#
-class TestCoreSuite(unittest.TestCase):
-
-    def assert_eval_cmp(self, a, b, klong=None):
-        self.assertTrue(eval_cmp(a, b, klong=klong))
-
-    def assert_eval_test(self, a, klong=None):
-        self.assertTrue(eval_test(a, klong=klong))""")
-    get_tests()
-
-    print("""
-    if __name__ == '__main__':
-        unittest.main()""")

tests/gen_test_fn.py

@@ -1,259 +0,0 @@
-import inspect
-import random
-import string
-
-from utils import *
-
-from klongpy import KlongInterpreter
-from klongpy.core import in_map, reserved_fn_symbol_map
-
-
-def wrap_lambda(arity, fn, fn_dict):
-    if arity == 0:
-        if len(fn_dict) == 0:
-            return lambda: fn()
-        elif 'm' in fn_dict and 'd' in fn_dict and 't' in fn_dict:
-            return lambda m=fn_dict['m'],d=fn_dict['d'],t=fn_dict['t']: fn(m,d,t)
-        elif 'm' in fn_dict and 'd' in fn_dict:
-            return lambda m=fn_dict['m'],d=fn_dict['d']: fn(m,d)
-        elif 'm' in fn_dict and 't' in fn_dict:
-            return lambda m=fn_dict['m'],t=fn_dict['t']: fn(m,t)
-        elif 'd' in fn_dict and 't' in fn_dict:
-            return lambda d=fn_dict['d'],t=fn_dict['t']: fn(d,t)
-        elif 'm' in fn_dict:
-            return lambda m=fn_dict['m']: fn(m)
-        elif 'd' in fn_dict:
-            return lambda d=fn_dict['d']: fn(d)
-        elif 't' in fn_dict:
-            return lambda t=fn_dict['t']: fn(t)
-    elif arity == 1:
-        if len(fn_dict) == 0:
-            return lambda x: fn(x)
-        elif 'm' in fn_dict and 'd' in fn_dict and 't' in fn_dict:
-            return lambda x,m=fn_dict['m'],d=fn_dict['d'],t=fn_dict['t']: fn(x,m=m,d=d,t=t)
-        elif 'm' in fn_dict and 'd' in fn_dict:
-            return lambda x,m=fn_dict['m'],d=fn_dict['d']: fn(x,m=m,d=d)
-        elif 'm' in fn_dict and 't' in fn_dict:
-            return lambda x,m=fn_dict['m'],t=fn_dict['t']: fn(x,m=m,t=t)
-        elif 'd' in fn_dict and 't' in fn_dict:
-            return lambda x,d=fn_dict['d'],t=fn_dict['t']: fn(x,d=d,t=t)
-        elif 'm' in fn_dict:
-            return lambda x,m=fn_dict['m']: fn(x,m=m)
-        elif 'd' in fn_dict:
-            return lambda x,d=fn_dict['d']: fn(x,d=d)
-        elif 't' in fn_dict:
-            return lambda x,t=fn_dict['t']: fn(x,t=t)
-    elif arity == 2:
-        if len(fn_dict) == 0:
-            return lambda x,y: fn(x,y)
-        elif 'm' in fn_dict and 'd' in fn_dict and 't' in fn_dict:
-            return lambda x,y,m=fn_dict['m'],d=fn_dict['d'],t=fn_dict['t']: fn(x,y,m=m,d=d,t=t)
-        elif 'm' in fn_dict and 'd' in fn_dict:
-            return lambda x,y,m=fn_dict['m'],d=fn_dict['d']: fn(x,y,m=m,d=d)
-        elif 'm' in fn_dict and 't' in fn_dict:
-            return lambda x,y,m=fn_dict['m'],t=fn_dict['t']: fn(x,y,m=m,t=t)
-        elif 'd' in fn_dict and 't' in fn_dict:
-            return lambda x,y,d=fn_dict['d'],t=fn_dict['t']: fn(x,y,d=d,t=t)
-        elif 'm' in fn_dict:
-            return lambda x,y,m=fn_dict['m']: fn(x,y,m=m)
-        elif 'd' in fn_dict:
-            return lambda x,y,d=fn_dict['d']: fn(x,y,d=d)
-        elif 't' in fn_dict:
-            return lambda x,y,t=fn_dict['t']: fn(x,y,t=t)
-    elif arity == 3:
-        if len(fn_dict) == 0:
-            return lambda x,y,z: fn(x,y,z)
-        elif 'm' in fn_dict and 'd' in fn_dict and 't' in fn_dict:
-            return lambda x,y,z,m=fn_dict['m'],d=fn_dict['d'],t=fn_dict['t']: fn(x,y,z,m=m,d=d,t=t)
-        elif 'm' in fn_dict and 'd' in fn_dict:
-            return lambda x,y,z,m=fn_dict['m'],d=fn_dict['d']: fn(x,y,z,m=m,d=d)
-        elif 'm' in fn_dict and 't' in fn_dict:
-            return lambda x,y,z,m=fn_dict['m'],t=fn_dict['t']: fn(x,y,z,m=m,t=t)
-        elif 'd' in fn_dict and 't' in fn_dict:
-            return lambda x,y,z,d=fn_dict['d'],t=fn_dict['t']: fn(x,y,z,d=d,t=t)
-        elif 'm' in fn_dict:
-            return lambda x,y,z,m=fn_dict['m']: fn(x,y,z,m=m)
-        elif 'd' in fn_dict:
-            return lambda x,y,z,d=fn_dict['d']: fn(x,y,z,d=d)
-        elif 't' in fn_dict:
-            return lambda x,y,z,t=fn_dict['t']: fn(x,y,z,t=t)
-
-
-class SymbolGenerator:
-    def __init__(self):
-        self.a = [n for n in list(string.ascii_lowercase) if not in_map(n, ['x','y','z','m','d','t'])]
-    def __iter__(self):
-        for n in self.a:
-            yield n
-        for n in self.a:
-            for m in self.a:
-                yield n+m
-        for n in self.a:
-            for m in self.a:
-                for o in self.a:
-                    yield n+m+o
-        for n in self.a:
-            for m in self.a:
-                for o in self.a:
-                    for p in self.a:
-                        yield n+m+o+p
-
-
-def create_symbols():
-    return iter(SymbolGenerator())
-
-def gensym(symbols):
-    return next(symbols)
-
-def fns(e,n,s):
-    return e.replace(n,s)
-
-fn_map = {
-    0: [
-        ("{0}", lambda: 0),
-        ("{m(1)}", lambda m: m(1), 0),
-        # ("{d}", lambda d: d, 2),
-        # ("{d(1;)}", lambda d: lambda x: d(1,x), 1),
-        ("{d(1;2)}", lambda d: d(1,2), 0),
-        ("{d(1;m(2))}", lambda m,d: d(1,m(2)), 0),
-        ("{d(m(2);1)}", lambda m,d: d(m(2),1), 0),
-        # ("{t}", lambda t: t, 3),
-        # ("{t(1;)}", lambda t: lambda x,y: t(1,x,y), 2),
-        # ("{t(1;2;)}", lambda t: lambda x: t(1,2,x), 1),
-        ("{t(1;2;3)}", lambda t: t(1,2,3), 0),
-        ("{t(m(1);2;3)}", lambda m,t: t(m(1),2,3), 0),
-        ("{t(1;m(2);3)}", lambda m,t: t(1,m(2),3), 0),
-        ("{t(1;2;m(3))}", lambda m,t: t(1,2,m(3)), 0),
-        ("{t(1;d(1;2);m(3))}", lambda m,d,t: t(1,d(1,2),m(3)), 0),
-        ("{t(d(1;2);m(2);3)}", lambda m,d,t: t(d(1,2),m(2),3), 0),
-        ("{t(d(1;2);2;m(3))}", lambda m,d,t: t(d(1,2),2,m(3)), 0),
-        ("{t(1;m(2);d(1;2))}", lambda m,d,t: t(1,m(2),d(1,2)), 0),
-        ("{t(m(1);d(1;2);3)}", lambda m,d,t: t(m(1),d(1,2),3), 0),
-        ("{t(m(1);2;d(1;2))}", lambda m,d,t: t(m(1),2,d(1,2)), 0),
-    ],
-    1: [
-        ("{x}", lambda x: x, 0),
-        ("{m(x)}", lambda x,m: m(x), 0),
-        ("{x;m(x)}", lambda x,m: m(x), 0),
-        ("{x;m(2*x)}", lambda x,m: m(2*x), 0),
-        # ("{.p(x)}", lambda x: str(x), 0),
-        # ("{d(x;)}", lambda d,x: lambda x1: d(x, x1), 1),
-        ("{d(x;x)}", lambda x,d: d(x,x), 0),
-        ("{d(1;x)}", lambda x,d: d(1, x), 0),
-        ("{d(x;1)}", lambda x,d: d(x, 1), 0),
-        ("{d(x;m(x))}", lambda x,m,d: d(x, m(x)), 0),
-        ("{d(m(x);x)}", lambda x,m,d: d(m(x), x), 0),
-        # ("{t(x;;)}", lambda t,x: lambda x1,y: t(x,x1,y), 2),
-        # ("{t(x;x;)}", lambda t,x: lambda x1: t(x,x,x1), 1),
-        ("{t(x;x;x)}", lambda x,t: t(x,x,x), 0),
-        ("{t(1;x;x)}", lambda x,t: t(1,x,x), 0),
-        ("{t(x;1;x)}", lambda x,t: t(x,1,x), 0),
-        ("{t(x;x;1)}", lambda x,t: t(x,x,1), 0),
-        ("{t(x;1;x)}", lambda x,t: t(x,1,x), 0),
-        ("{t(1;2;x)}", lambda x,t: t(1,2,x), 0),
-        ("{t(1;x;2)}", lambda x,t: t(1,x,2), 0),
-        ("{t(2;x;1)}", lambda x,t: t(2,x,1), 0),
-        ("{t(x;1;2)}", lambda x,t: t(x,1,2), 0),
-        ("{t(x;2;1)}", lambda x,t: t(x,2,1), 0),
-    ],
-    2: [
-        ("{x+y}", lambda x,y: x+y),
-        ("{x+m(y)}", lambda x,y,m: x+m(y), 0),
-        ("{m(x)+m(y)}", lambda x,y,m: m(x)+m(y), 0),
-        # ("{t(x;y;)}", lambda t,x,y: lambda x1: t(x,y,x1), 1),
-        ("{t(x;y;y)}", lambda x,y,t: t(x,y,y), 0),
-        ("{t(x;y;m(y))}", lambda x,y,m,t: t(x,y,m(y)), 0),
-        ("{t(x;d(x;y);m(y))}", lambda x,y,m,d,t: t(x,d(x,y),m(y)), 0),
-    ],
-    3: [
-        ("{x+y+z}", lambda x,y,z: x+y+z, 0),
-        ("{x+y+m(z)}", lambda x,y,z,m: x+y+m(z), 0),
-        ("{m(x)+m(y)+m(z)}", lambda x,y,z,m: m(x)+m(y)+m(z), 0),
-        ("{x+d(y;z)}", lambda x,y,z,d: x+d(y,z), 0),
-        ("{m(x)+d(y;z)}", lambda x,y,z,m,d: m(x) + d(y,z), 0),
-        ("{d(x;y)+m(z)}", lambda x,y,z,m,d: d(x,y) + m(z), 0),
-        ("{d(x;y)+d(x;z)}", lambda x,y,z,d: d(x,y) + d(x,z), 0),
-        ("{d(x;m(y))+d(m(x);z)}", lambda x,y,z,m,d: d(x,m(y)) + d(m(x),z), 0),
-        # ("{d(m(x+y+z);)}", lambda x,y,z,m,d: lambda x1: d(m(x)+y+z,x1), 1)
-    ]
-}
-
-def gen_fn(arity,symbols,fn_name=None,level=0,max_level=100):
-    if level > max_level:
-        raise RecursionError()
-    arr = []
-    choices = fn_map[arity]
-    q = choices[random.randint(0,len(choices)-1)]
-    fnd = q[0]
-    fn_name = fn_name or gensym(symbols)
-    if fn_name is None:
-        return arr
-    args = inspect.getfullargspec(q[1]).args
-    fn_dict = {}
-    if len(args) == 0:
-        pass
-    else:
-        if 'm' in args:
-            s = gensym(symbols)
-            fnd = fns(fnd,'m',s)
-            _,aa,ff = gen_fn(1,symbols,fn_name=s,level=level+1)
-            fn_dict['m'] = ff
-            arr.extend(aa)
-        if 'd' in args:
-            s = gensym(symbols)
-            fnd = fns(fnd,'d',s)
-            _,aa,ff = gen_fn(2,symbols,fn_name=s,level=level+1)
-            fn_dict['d'] = ff
-            arr.extend(aa)
-        if 't' in args:
-            s = gensym(symbols)
-            fnd = fns(fnd,'t',s)
-            _,aa,ff = gen_fn(3,symbols,fn_name=s,level=level+1)
-            fn_dict['t'] = ff
-            arr.extend(aa)
-    fn = f"{fn_name}::{fnd}"
-    arr.append(fn)
-    return fn_name,arr,wrap_lambda(arity,q[1],fn_dict)
-
-
-def gen_tests():
-    random.seed(0)
-    seen = set()
-    for arity in range(4):
-        for _ in range(10000):
-            try:
-                fn_name, arr, fn = gen_fn(arity,create_symbols(), max_level=100)
-            except RecursionError as e:
-                continue
-            klong = KlongInterpreter()
-            stmt = "; ".join(arr)
-            if stmt in seen or len(arr) > 10: # filter out redundant and too complex (slow) calcs
-                continue
-            seen.add(stmt)
-            klong(stmt)
-            if arity == 0:
-                fr = fn()
-                kr = f"{fn_name}()"
-            else:
-                args = [1,2,3][:arity]
-                fr = fn(*args)
-                kr = f"{fn_name}({';'.join([str(x) for x in args])})"
-            print(stmt)
-            print(f't(\"{stmt}; {kr}\"; {kr}; {fr})')
-
-
-if __name__ == '__main__':
-    print("""
-:"DO NOT MODIFY: GENERATED BY gen_test_fn.py"
-
-err::0
-wl::{.w(x);.p("")}
-fail::{err::1;.d("failed: ");.p(x);.d("expected: ");wl(z);.d("got: ");wl(y);[]}
-t::{:[~y~z;fail(x;y;z);[]]}
-
-""")
-    gen_tests()
-
-    print("""
-:[err;[];.p("ok!")]
-""")

tests/perf_async.py

@@ -1,25 +0,0 @@
-import timeit
-import asyncio
-
-# Non-async function with recursive calls
-def normal_function(n):
-    if n == 0:
-        return 1
-    return normal_function(n-1) + 1
-
-# Async function with recursive calls
-async def async_function(n):
-    if n == 0:
-        return 1
-    return await async_function(n-1) + 1
-
-# Wrapper function to run async function
-def run_async_function():
-    return asyncio.run(async_function(10))
-
-# Measure the time taken by both functions
-non_async_time = timeit.timeit("normal_function(10)", globals=globals(), number=100000)
-async_time = timeit.timeit("run_async_function()", globals=globals(), number=100000)
-
-print(f"Non-async time: {non_async_time:.6f} seconds")
-print(f"Async time: {async_time:.6f} seconds")

tests/perf_avg.py

@@ -1,18 +0,0 @@
-import time
-from klongpy.backend import np
-from klongpy import KlongInterpreter
-
-klong = KlongInterpreter()
-
-# define average function in Klong. Note, the '+/' (sum over) uses np.add.reduce under the hood
-klong('avg::{(+/x)%#x}')
-
-# create a billion random ints
-data = np.random.rand(10**9)
-
-# run Klong average function
-start = time.perf_counter_ns()
-r = klong['avg'](data)
-stop = time.perf_counter_ns()
-
-print(f"avg={np.round(r,6)} in {round((stop - start) / (10**9),6)} seconds")

tests/perf_duckdb.py

@@ -1,32 +0,0 @@
-import duckdb
-import numpy as np
-import pandas as pd
-import time
-
-N = 1000000
-
-# Create a NumPy array
-data = np.arange(N, dtype=int)
-data2 = np.arange(N, dtype=int)
-
-df = pd.DataFrame({'c': data, 'd': data2})
-
-con = duckdb.connect(':memory:')
-
-# Register the DataFrame as a DuckDB table
-#start_t = time.time_ns()
-#con.register('T', df)
-#print("register: ", time.time_ns() - start_t)
-
-def call_db(sql, T):
-    start_t = time.time_ns()
-    result = con.execute(f'SELECT * FROM T where c > {N-10} and d > {N-5}').fetchdf()
-    return time.time_ns() - start_t
-
-avgs = []
-sql = f'SELECT * FROM df where c > {N-10} and d > {N-5}'
-for i in range(1000):
-    avgs.append(call_db(sql,df))
-avg = sum(avgs)/len(avgs)
-print(N, avg, avg / len(data))
-

tests/perf_gen.py

@@ -1,38 +0,0 @@
-import glob
-import math
-import os
-import unittest
-
-from utils import *
-
-import timeit
-
-def parse_suite_file(fname, number=10):
-    klong = KlongInterpreter()
-    with open(fname, "r") as f:
-        d = f.read()
-        b = len(d) * number
-        r = timeit.timeit(lambda: klong(d), number=number)
-        return b, r, int(b / r), r / number
-
-
-def test_kgtests():
-    """
-    Recursively run all tests under the kgtests folder that begin with "test" and end with ".kg".
-    """
-    root_dir = os.path.join(os.getcwd(), "tests", "kgtests")
-
-    for dirpath, _, filenames in os.walk(root_dir):
-        for fname in filenames:
-            if (fname.startswith("gen")) and fname.endswith(".kg"):
-                ran_tests = True
-                klong = KlongInterpreter()
-                fullpath = os.path.join(dirpath, fname)
-                klong['fullpath'] = fullpath
-                klong('.l("tests/kgtests/runner.kg")')
-                if fname.startswith("gen"):
-                    r = parse_suite_file(fullpath)
-                    print(f"total: {r[1]} iter: {r[-1]}")
-
-if __name__ == "__main__":
-    test_kgtests()

tests/perf_ipc_overhead.py

@@ -1,34 +0,0 @@
-import timeit
-import uuid
-import queue
-import threading
-
-def gen_uuid_msg_id():
-    return uuid.uuid4().bytes
-
-def alloc_queue():
-    return queue.Queue()
-
-def alloc_event():
-    return threading.Event()
-
-def nop_fn():
-    return 1
-
-def implicit_lambda():
-    foo = 1
-    def return_foo():
-        return foo
-    return return_foo()
-
-nop_fn = timeit.timeit("nop_fn()", globals=globals(), number=100000)
-gen_uuid_time = timeit.timeit("gen_uuid_msg_id()", globals=globals(), number=100000)
-alloc_queue_time = timeit.timeit("alloc_queue()", globals=globals(), number=100000)
-alloc_event_time = timeit.timeit("alloc_event()", globals=globals(), number=100000)
-implicit_lambda_time = timeit.timeit("implicit_lambda()", globals=globals(), number=100000)
-
-print(f"nop_fn: {nop_fn:.6f} seconds per: {nop_fn/100000}")
-print(f"gen_uuid_time: {gen_uuid_time:.6f} seconds per: {gen_uuid_time/100000}")
-print(f"alloc_queue_time: {alloc_queue_time:.6f} seconds per: {alloc_queue_time/100000}")
-print(f"alloc_event_time: {alloc_event_time:.6f} seconds per: {alloc_event_time/100000}")
-print(f"implicit_lambda_time: {implicit_lambda_time:.6f} seconds per: {implicit_lambda_time/100000}")

tests/perf_join.py

@@ -1,53 +0,0 @@
-import sys
-from os import path
-sys.path.append(path.abspath(path.join(path.dirname(__file__), '..')))
-
-from utils import *
-from klongpy.core import read_string
-import timeit
-
-
-def perf_join(k,number):
-    a = "a" * k
-    b = [x for x in a]
-    r = timeit.timeit(lambda b=b: "".join(b), number=number)
-    kr = r/number
-    print(k,kr)
-    return kr
-
-
-def perf_read_string(s, number=1000):
-    i = s.index('"')+1
-    r = timeit.timeit(lambda t=s,i=i: read_string(t,i), number=number)
-    kr = r/number
-    print(s, kr)
-    return kr
-
-
-"""
-some basic perf test for python join operator.
-"""
-
-if __name__ == "__main__":
-    perf_join(100,10000)
-    perf_join(1000,10000)
-    perf_join(10000,10000)
-
-    t = '"hello"'
-    perf_read_string(t)
-    t = 'this is "hello" test'
-    perf_read_string(t)
-    t = 'this is "hello""""world" test'
-    perf_read_string(t)
-    t = 'this is "hello""""""world" test'
-    perf_read_string(t)
-    t = '""'
-    perf_read_string(t)
-    t = '""""'
-    perf_read_string(t)
-    t = '""""""'
-    perf_read_string(t)
-    t = '":["""";1;2]"'
-    perf_read_string(t)
-    t = 'A::""hello, world!""'
-    perf_read_string(t)

tests/perf_load.py

@@ -1,17 +0,0 @@
-import os
-import timeit
-
-import numpy as np
-from utils import load_lib_file
-
-from klongpy import KlongInterpreter
-
-
-def perf_load_lib(number=100):
-    r = timeit.timeit(lambda: load_lib_file('nstat.kg'), number=number)
-    return r/number
-
-
-if __name__ == "__main__":
-    number = 1000
-    perf_load_lib(1000)

tests/perf_prog.py

@@ -1,18 +0,0 @@
-import timeit
-
-from klongpy import KlongInterpreter
-
-
-def parse_suite_file(fname, number=10):
-    klong = KlongInterpreter()
-    with open(f"tests/{fname}", "r") as f:
-        d = f.read()
-        b = len(d) * number
-        r = timeit.timeit(lambda: klong.prog(d), number=number)
-        return b, r, int(b / r), r / number
-
-
-if __name__ == "__main__":
-    number = 20
-    b,r,bps,avg = parse_suite_file("kgtests/language/test_join_over.kg", number=number)
-    print(f"bytes processed: {b} time: {round(r,5)} bytes-per-second: {bps} time-per-pass: {round(avg,5)}")

tests/perf_serdes.py

@@ -1,52 +0,0 @@
-import numpy as np
-import pickle
-import dill
-import timeit
-import zlib
-
-# Create a large numpy array
-#large_array = np.random.rand(10000, 10000)
-large_array = np.random.rand(100000)
-
-size_in_bytes = large_array.nbytes
-print(f"Size of the numpy array: {size_in_bytes} bytes")
-print()
-
-# Define number of iterations
-N = 10
-
-# Pickle serialization
-pickle_serialize_time = timeit.timeit(lambda: pickle.dumps(large_array), number=N)
-print(f"Average pickle serialization time: {pickle_serialize_time / N} seconds")
-
-# Pickle deserialization
-pickle_data = pickle.dumps(large_array)
-print("len(pickle_data): ",len(pickle_data))
-pickle_deserialize_time = timeit.timeit(lambda: pickle.loads(pickle_data), number=N)
-print(f"Average pickle deserialization time: {pickle_deserialize_time / N} seconds")
-print()
-
-# Dill serialization
-dill_serialize_time = timeit.timeit(lambda: dill.dumps(large_array), number=N)
-print(f"Average dill serialization time: {dill_serialize_time / N} seconds")
-
-# Dill deserialization
-dill_data = dill.dumps(large_array)
-print("len(dill_data): ",len(dill_data))
-dill_deserialize_time = timeit.timeit(lambda: dill.loads(dill_data), number=N)
-print(f"Average dill deserialization time: {dill_deserialize_time / N} seconds")
-print()
-
-# Dill serialization with deflate
-dill_serialize_time = timeit.timeit(lambda: zlib.compress(dill.dumps(large_array), level=0), number=N)
-print(f"Average dill serialization time with deflate: {dill_serialize_time / N} seconds")
-print()
-
-# Dill deserialization with deflate
-dill_data = zlib.compress(dill.dumps(large_array),level=0)
-print("len(compressed_dill_data): ",len(dill_data))
-dill_deserialize_time = timeit.timeit(lambda: dill.loads(zlib.decompress(dill_data)), number=N)
-print(f"Average dill deserialization time with deflate: {dill_deserialize_time / N} seconds")
-print()
-
-