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

klongpy/sys_fn.py

@@ -12,8 +12,24 @@ from inspect import Parameter
 import numpy
 
 from .core import (KGChannel, KGChannelDir, KGLambda, KGSym, KlongException,
-                   is_dict, is_empty, is_list, kg_asarray, kg_read, kg_write, np,
+                   is_dict, is_empty, is_list, kg_read, kg_write, np,
                    reserved_fn_args, reserved_fn_symbol_map, safe_eq, safe_inspect)
+from .backend import to_numpy, get_default_backend, kg_asarray
+
+
+def _to_display_value(x):
+    """Convert backend tensors to numpy for cleaner display."""
+    backend = get_default_backend()
+    # Convert backend arrays (tensors) to numpy
+    if backend.is_backend_array(x):
+        return to_numpy(x)
+    # Handle numpy arrays with tensors inside (object arrays)
+    if isinstance(x, numpy.ndarray) and x.dtype == object:
+        return numpy.array([_to_display_value(item) for item in x], dtype=object)
+    # Handle lists with tensors
+    if isinstance(x, list):
+        return [_to_display_value(item) for item in x]
+    return x
 
 
 def eval_sys_append_channel(x):
@@ -47,10 +63,25 @@ def eval_sys_display(klong, x):
 
         .d(x)                                                  [Display]
 
-        See [Write].
+        Display the object "x". Tensors are converted to numpy for cleaner output.
+        Use .bkd() for raw backend-specific display.
+
+    """
+    x = _to_display_value(x)
+    r = kg_write(x, klong._backend, display=True)
+    klong['.sys.cout'].raw.write(r)
+    return r
+
+
+def eval_sys_backend_display(klong, x):
+    """
+
+        .bkd(x)                                        [Backend-Display]
+
+        Display the object "x" in raw backend format (tensors shown as-is).
 
     """
-    r = kg_write(x, display=True)
+    r = kg_write(x, klong._backend, display=True)
     klong['.sys.cout'].raw.write(r)
     return r
 
@@ -272,10 +303,26 @@ def eval_sys_print(klong, x):
         .p(x)                                                    [Print]
 
         Pretty-print the object "x" (like Display) and then print a
-        newline sequence. .p("") will just print a newline.
+        newline sequence. Tensors are converted to numpy for cleaner output.
+        Use .bkp() for raw backend-specific print.
+
+    """
+    x = _to_display_value(x)
+    o = kg_write(x, klong._backend, display=True)
+    klong['.sys.cout'].raw.write(o+"\n")
+    return o
+
+
+def eval_sys_backend_print(klong, x):
+    """
+
+        .bkp(x)                                          [Backend-Print]
+
+        Pretty-print the object "x" in raw backend format (tensors shown as-is)
+        and then print a newline sequence.
 
     """
-    o = kg_write(x, display=True)
+    o = kg_write(x, klong._backend, display=True)
     klong['.sys.cout'].raw.write(o+"\n")
     return o
 
@@ -341,20 +388,30 @@ def _handle_import(item):
             if n_args <= len(reserved_fn_args):
                 item = KGLambda(item, args=reserved_fn_args[:n_args])
         else:
-            args = safe_inspect(item, follow_wrapped=True)
-            if 'args' in args:
+            sig_args = safe_inspect(item, follow_wrapped=True)
+            if 'args' in sig_args:
                 item = KGLambda(item, args=None, wildcard=True)
                 n_args = 3
             else:
-                args = [k for k,v in args.items() if (v.kind == Parameter.POSITIONAL_OR_KEYWORD and v.default == Parameter.empty) or (v.kind == Parameter.POSITIONAL_ONLY)]
-                n_args = len(args)
-                # if there are kwargs, then .pyc() must be used to call this function to override them
-                if 'klong' in args:
-                    n_args -= 1
-                    assert n_args <= len(reserved_fn_args)
-                    item = KGLambda(item, args=reserved_fn_args[:n_args], provide_klong=True)
-                elif n_args <= len(reserved_fn_args):
-                    item = KGLambda(item, args=reserved_fn_args[:n_args])
+                # Get required args (no default)
+                required_args = [k for k,v in sig_args.items() if (v.kind == Parameter.POSITIONAL_OR_KEYWORD and v.default == Parameter.empty) or (v.kind == Parameter.POSITIONAL_ONLY)]
+                # Get optional args (have default)
+                optional_args = [k for k,v in sig_args.items() if v.kind == Parameter.POSITIONAL_OR_KEYWORD and v.default != Parameter.empty]
+                # Use required args count, but if there are optional args and no required args,
+                # use wildcard mode so the function can accept 0-3 args
+                if not required_args and optional_args:
+                    item = KGLambda(item, args=None, wildcard=True)
+                    n_args = 3
+                else:
+                    args = required_args
+                    n_args = len(args)
+                    # if there are kwargs, then .pyc() must be used to call this function to override them
+                    if 'klong' in args:
+                        n_args -= 1
+                        assert n_args <= len(reserved_fn_args)
+                        item = KGLambda(item, args=reserved_fn_args[:n_args], provide_klong=True)
+                    elif n_args <= len(reserved_fn_args):
+                        item = KGLambda(item, args=reserved_fn_args[:n_args])
     except Exception:
         if hasattr(item, "__class__") and hasattr(item.__class__, '__module__') and item.__class__.__module__ == "builtins":
             # LOOK AWAY. You didn't see this.
@@ -405,7 +462,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:
@@ -415,6 +472,17 @@ def _import_module(klong, x, from_set=None):
                 except Exception as e:
                     # TODO: this should be logged
                     print(f"failed to import function: {name}", e)
+
+            # For from_set imports, also check for lazy-loaded attributes not in __dict__
+            # (e.g., numpy.random in numpy 2.x)
+            if from_set is not None:
+                for name in from_set:
+                    if name not in export_items and hasattr(module, name):
+                        try:
+                            item = getattr(module, name)
+                            klong[name] = _handle_import(item)
+                        except Exception as e:
+                            print(f"failed to import function: {name}", e)
         finally:
             klong._context.push(ctx)
 
@@ -578,6 +646,49 @@ def eval_sys_python_from(klong, x, y):
     return _import_module(klong, x, from_set=set(y))
 
 
+def eval_sys_backend_fn(klong, x):
+    """
+
+        .bkf(x)                                           [Backend-Function]
+
+        Import functions from the current backend's array module.
+        This is similar to .pyf() but uses backend-aware functions that
+        work with both numpy and torch backends.
+
+        When using the torch backend, these functions preserve gradient
+        tracking for autograd.
+
+        Example:
+
+            .bkf("exp")
+            exp(1.0) --> 2.718...
+
+            .bkf(["exp";"sin";"cos"])
+            sin(1.0) --> 0.841...
+
+        Common functions available: exp, sin, cos, tan, tanh, sqrt, abs,
+        log, log10, floor, ceil, round
+
+    """
+    if isinstance(x, str):
+        x = [x]
+    if not (is_list(x) and all(map(lambda p: isinstance(p, str), x))):
+        raise RuntimeError("function name(s) must be a string or list of strings")
+
+    backend = klong._backend
+    ctx = klong._context.pop()
+    try:
+        for fn_name in x:
+            if hasattr(backend.np, fn_name):
+                fn = getattr(backend.np, fn_name)
+                klong[fn_name] = _handle_import(fn)
+            else:
+                raise RuntimeError(f"Backend does not have function: {fn_name}")
+    finally:
+        klong._context.push(ctx)
+    return None
+
+
 def eval_sys_random_number():
     """
 
@@ -722,7 +833,7 @@ def eval_sys_write(klong, x):
         sequence. Use .p (Print) to do so.
 
     """
-    r = kg_write(x)
+    r = kg_write(x, klong._backend)
     klong['.sys.cout'].raw.write(r)
     return x
 

klongpy/sys_fn_autograd.py

@@ -0,0 +1,290 @@
+"""
+Autograd system functions for KlongPy.
+
+Provides .jacobian() for Jacobian matrix computation.
+Provides .compile() for function compilation and graph export (torch only).
+
+For optimizers (SGD, Adam, etc.), see examples/autograd/optimizers.py
+which can be copied to your project and customized.
+"""
+import sys
+
+from .autograd import jacobian_of_fn, _invoke_fn
+
+
+def eval_sys_jacobian(klong, x, y):
+    """
+
+        .jacobian(x;y)                                          [Jacobian]
+
+        Compute Jacobian matrix of function x at point y.
+
+        For f: R^n -> R^m, returns m x n matrix where J[i,j] = df_i/dx_j.
+
+        Examples:
+            f::{[x@0^2 x@1^2]}
+            .jacobian(f;[1 2])   -->  [[2 0] [0 4]]
+
+    """
+    return jacobian_of_fn(klong, x, y)
+
+
+def eval_sys_compile(klong, x, y):
+    """
+
+        .compile(x;y)                                           [Compile]
+
+        Compile a function for optimized execution using torch.compile.
+        Requires PyTorch backend (USE_TORCH=1).
+
+        Arguments:
+            x           - Function to compile
+            y           - Example input for tracing the computation graph
+
+        Returns:
+            Compiled function (faster execution)
+
+        Examples:
+            f::{x^2}
+            cf::.compile(f;3.0)          :" Returns compiled function
+            cf(5.0)                       :" 25.0 (optimized)
+
+        Notes:
+            - Only supported with PyTorch backend
+            - Raises error on NumPy backend
+            - See .export() for saving graphs to files
+
+    """
+    fn, example_input = x, y
+
+    backend = klong._backend
+    if not backend.supports_autograd():
+        raise RuntimeError(
+            ".compile() requires PyTorch backend. "
+            "Run with USE_TORCH=1 environment variable."
+        )
+
+    # Wrap the Klong function for torch
+    def wrapped_fn(v):
+        return _invoke_fn(klong, fn, [v])
+
+    return backend.compile_function(wrapped_fn, example_input, None)
+
+
+def eval_sys_export(klong, x, y, z):
+    """
+
+        .export(x;y;z)                                          [Export]
+
+        Export a function's computation graph to a file for inspection.
+        Requires PyTorch backend (USE_TORCH=1).
+
+        Arguments:
+            x           - Function to export
+            y           - Example input for tracing the computation graph
+            z           - Path to save the graph (.pt2 file)
+
+        Returns:
+            Dictionary with:
+                "compiled_fn" - The compiled function
+                "export_path" - Path where graph was saved
+                "graph"       - String representation of computation graph
+
+        Examples:
+            f::{x^2}
+            info::.export(f;3.0;"model.pt2")
+            .p(info@"graph")              :" Print computation graph
+
+        Notes:
+            - Only supported with PyTorch backend
+            - The exported graph can be loaded with torch.export.load()
+            - Use .compile() for just compiling without export
+
+    """
+    fn, example_input, output_path = x, y, z
+
+    backend = klong._backend
+    if not backend.supports_autograd():
+        raise RuntimeError(
+            ".export() requires PyTorch backend. "
+            "Run with USE_TORCH=1 environment variable."
+        )
+
+    # Wrap the Klong function for torch
+    def wrapped_fn(v):
+        return _invoke_fn(klong, fn, [v])
+
+    return backend.compile_function(wrapped_fn, example_input, output_path)
+
+
+def eval_sys_compilex(klong, x, y, z):
+    """
+
+        .compilex(x;y;z)                                        [Compile-Extended]
+
+        Compile a function with extended options for mode and backend.
+        Requires PyTorch backend (USE_TORCH=1).
+
+        Arguments:
+            x           - Function to compile
+            y           - Example input for tracing the computation graph
+            z           - Options dictionary with compile settings
+
+        Options (z):
+            "mode"      - Compilation mode:
+                          "default"         - Balanced (default)
+                          "reduce-overhead" - Faster compile, less optimization
+                          "max-autotune"    - Slower compile, best runtime
+            "backend"   - Compilation backend:
+                          "inductor"   - Default with C++/Triton codegen
+                          "eager"      - No compilation (debugging)
+                          "cudagraphs" - CUDA graphs (GPU only)
+            "fullgraph" - 1 to require full graph compilation
+            "dynamic"   - 1 for dynamic shapes, 0 for static
+
+        Mode Comparison:
+            | Mode            | Compile | Runtime | Use Case          |
+            |-----------------|---------|---------|-------------------|
+            | default         | Medium  | Good    | General use       |
+            | reduce-overhead | Fast    | OK      | Development       |
+            | max-autotune    | Slow    | Best    | Production        |
+
+        Returns:
+            Compiled function
+
+        Examples:
+            f::{x^2}
+
+            :" Fast compilation for development
+            cf::.compilex(f;3.0;:{["mode" "reduce-overhead"]})
+
+            :" Maximum optimization for production
+            cf::.compilex(f;3.0;:{["mode" "max-autotune"]})
+
+            :" Debug mode (no compilation)
+            cf::.compilex(f;3.0;:{["backend" "eager"]})
+
+        Notes:
+            - Only supported with PyTorch backend
+            - Requires C++ compiler for inductor backend
+            - Use .cmodes() to see all available options
+
+    """
+    fn, example_input, options = x, y, z
+
+    backend = klong._backend
+    if not backend.supports_autograd():
+        raise RuntimeError(
+            ".compilex() requires PyTorch backend. "
+            "Run with USE_TORCH=1 environment variable."
+        )
+
+    # Extract options from dictionary
+    mode = options.get("mode", "default") if isinstance(options, dict) else "default"
+    compile_backend = options.get("backend", "inductor") if isinstance(options, dict) else "inductor"
+    fullgraph = bool(options.get("fullgraph", 0)) if isinstance(options, dict) else False
+    dynamic = None
+    if isinstance(options, dict) and "dynamic" in options:
+        dynamic = bool(options["dynamic"])
+
+    # Wrap the Klong function for torch
+    def wrapped_fn(v):
+        return _invoke_fn(klong, fn, [v])
+
+    return backend.compile_function(
+        wrapped_fn, example_input, None,
+        mode=mode, backend=compile_backend, fullgraph=fullgraph, dynamic=dynamic
+    )
+
+
+def eval_sys_cmodes(klong):
+    """
+
+        .cmodes()                                               [Compile-Modes]
+
+        Get information about available torch.compile modes and backends.
+        Requires PyTorch backend (USE_TORCH=1).
+
+        Returns:
+            Dictionary with:
+                "modes"           - Available compilation modes
+                "backends"        - Available compilation backends
+                "recommendations" - Suggested settings for common use cases
+
+        Examples:
+            info::.cmodes()
+            .p(info@"modes")          :" Print available modes
+            .p(info@"recommendations") :" Print recommended settings
+
+        Mode Comparison:
+            | Mode            | Compile Time | Runtime Speed | Best For     |
+            |-----------------|--------------|---------------|--------------|
+            | default         | Medium       | Good          | General use  |
+            | reduce-overhead | Fast         | Moderate      | Development  |
+            | max-autotune    | Slow         | Best          | Production   |
+
+        Backend Comparison:
+            | Backend    | Description                              |
+            |------------|------------------------------------------|
+            | inductor   | Default - C++/Triton code generation     |
+            | eager      | No compilation - for debugging           |
+            | cudagraphs | CUDA graphs - reduces GPU launch overhead|
+
+    """
+    backend = klong._backend
+    if not backend.supports_autograd():
+        raise RuntimeError(
+            ".cmodes() requires PyTorch backend. "
+            "Run with USE_TORCH=1 environment variable."
+        )
+
+    return backend.get_compile_modes()
+
+
+def eval_sys_gradcheck(klong, x, y):
+    """
+
+        .gradcheck(x;y)                                         [Gradcheck]
+
+        Verify that autograd gradients match numeric gradients.
+        Uses torch.autograd.gradcheck for rigorous verification.
+        Requires PyTorch backend (USE_TORCH=1).
+
+        Arguments:
+            x       - Function to check (should return a scalar)
+            y       - Input value or list of inputs to check
+
+        Returns:
+            1 if gradients are correct
+            Raises error if gradients don't match
+
+        Examples:
+            f::{x^2}
+            .gradcheck(f;3.0)            :" Returns 1
+
+            g::{(x@0^2)+(x@1^2)}
+            .gradcheck(g;[1.0 2.0])      :" Returns 1
+
+        Notes:
+            - Only supported with PyTorch backend
+            - Uses double precision (float64) when available (CPU/CUDA)
+            - Falls back to float32 with relaxed tolerances on MPS
+            - Useful for verifying custom gradient implementations
+
+    """
+    return klong._backend.klong_gradcheck(klong, x, y)
+
+
+def create_system_functions_autograd():
+    """Create registry of autograd system functions."""
+    def _get_name(s):
+        i = s.index('.')
+        return s[i:i+s[i:].index('(')]
+
+    registry = {}
+    m = sys.modules[__name__]
+    for x in filter(lambda n: n.startswith("eval_sys_"), dir(m)):
+        fn = getattr(m, x)
+        registry[_get_name(fn.__doc__)] = fn
+
+    return registry

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
@@ -941,20 +940,31 @@ def eval_sys_fn_create_ipc_server(klong, x):
 
 
 class KGAsyncCall(KGLambda):
-    def __init__(self, klongloop, fn, cb):
+    def __init__(self, klongloop, fn, cb, klong):
         self.klongloop = klongloop
-        self.cb = cb
-        self.fn = fn
-        arity = fn.get_arity() if issubclass(type(self.fn), KGLambda) else fn.arity
+        self.klong = klong
+
+        # Wrap callbacks - KGFnWrapper now handles dynamic resolution automatically
+        self.fn = KGFnWrapper(klong, fn) if isinstance(fn, KGFn) else fn
+        self.cb = KGFnWrapper(klong, cb) if isinstance(cb, KGFn) else cb
+
+        arity = fn.get_arity() if issubclass(type(fn), KGLambda) else fn.arity
         self.args = [reserved_fn_symbol_map[x] for x in reserved_fn_args[:arity]]
 
     async def acall(self, klong, params):
+        # Execute the function based on its type
         if issubclass(type(self.fn), KGLambda):
             ctx = {reserved_fn_symbols[i]:params[i] for i in range(min(len(reserved_fn_args),len(params)))}
             r = self.fn(klong, ctx)
+        elif callable(self.fn):
+            r = self.fn(*params)
         else:
+            # Shouldn't reach here, but handle it
             r = klong.call(KGCall(self.fn.a, [*params], self.fn.arity))
-        self.cb(r)
+
+        # Invoke callback - KGFnWrapper handles dynamic resolution automatically
+        if self.cb is not None:
+            self.cb(r)
 
     def __call__(self, klong, ctx):
         params = [ctx[x] for x in self.args]
@@ -980,7 +990,8 @@ def eval_sys_fn_create_async_wrapper(klong, x, y):
         raise KlongException("y must be a function")
     system = klong['.system']
     klongloop = system['klongloop']
-    return KGAsyncCall(klongloop, x, KGFnWrapper(klong, y))
+    # KGAsyncCall will wrap the callbacks automatically
+    return KGAsyncCall(klongloop, x, y, klong)
 
 
 def create_system_functions_ipc():

klongpy/sys_fn_timer.py

@@ -54,6 +54,8 @@ def eval_sys_fn_timer(klong, x, y, z):
 
         The callback function returns 1 to continue, 0 to stop time timer.
 
+        If "z" is a named function, the timer re-resolves it on each tick so redefinitions take effect.
+
         Example:
 
             cb::{.p("hello")}
@@ -76,12 +78,20 @@ def eval_sys_fn_timer(klong, x, y, z):
     y= int(y)
     if y < 0:
         return "x must be a non-negative integer"
-    z = z if isinstance(z, KGCall) else KGFnWrapper(klong, z) if isinstance(z, KGFn) else z
-    if not callable(z):
+
+    # Wrap the callback - KGFnWrapper now handles dynamic resolution automatically
+    if isinstance(z, KGCall):
+        return "z must be a function (not a function call)"
+    if isinstance(z, KGFn):
+        callback = KGFnWrapper(klong, z)
+    elif callable(z):
+        callback = z
+    else:
         return "z must be a function"
+
     system = klong['.system']
     klongloop = system['klongloop']
-    return _call_periodic(klongloop, x, y, z)
+    return _call_periodic(klongloop, x, y, callback)
 
 
 def eval_sys_fn_cancel_timer(x):

klongpy/web/sys_fn_web.py

@@ -1,5 +1,7 @@
 import logging
 import sys
+import asyncio
+import concurrent.futures
 
 from aiohttp import web
 
@@ -67,9 +69,14 @@ def eval_sys_fn_create_web_server(klong, x, y, z):
         if arity != 1:
             logging.info(f"GET route {route} handler function requires arity 1, got {arity}")
             continue
-        fn = fn if isinstance(fn, KGCall) else KGFnWrapper(klong, fn) if isinstance(fn, KGFn) else fn
 
-        async def _get(request: web.Request, fn=fn, route=route):
+        # Wrap function - KGFnWrapper now handles dynamic resolution automatically
+        if isinstance(fn, KGCall):
+            logging.info(f"GET route {route} handler cannot be a function call")
+            continue
+        fn_wrapped = KGFnWrapper(klong, fn) if isinstance(fn, KGFn) else fn
+
+        async def _get(request: web.Request, fn=fn_wrapped, route=route):
             try:
                 assert request.method == "GET"
                 return web.Response(text=str(fn(dict(request.rel_url.query))))
@@ -86,9 +93,14 @@ def eval_sys_fn_create_web_server(klong, x, y, z):
         if arity != 1:
             logging.info(f"POST route {route} handler function requires arity 1, got {arity}")
             continue
-        fn = fn if isinstance(fn, KGCall) else KGFnWrapper(klong, fn) if isinstance(fn, KGFn) else fn
 
-        async def _post(request: web.Request, fn=fn):
+        # Wrap function - KGFnWrapper now handles dynamic resolution automatically
+        if isinstance(fn, KGCall):
+            logging.info(f"POST route {route} handler cannot be a function call")
+            continue
+        fn_wrapped = KGFnWrapper(klong, fn) if isinstance(fn, KGFn) else fn
+
+        async def _post(request: web.Request, fn=fn_wrapped, route=route):
             try:
                 assert request.method == "POST"
                 parameters = dict(await request.post())
@@ -113,7 +125,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 +151,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