IncludeCPP 3.4.2__py3-none-any.whl → 3.4.8__py3-none-any.whl

includecpp/core/cssl/cssl_types.py

@@ -346,6 +346,49 @@ class OpenQuote:
         return self._data
 
 
+class Parameter:
+    """Parameter accessor for CSSL exec() arguments.
+
+    Provides access to arguments passed to CSSL.exec() via parameter.get(index).
+
+    Usage in CSSL:
+        parameter.get(0)  # Get first argument
+        parameter.get(1)  # Get second argument
+        parameter.count() # Get total argument count
+        parameter.all()   # Get all arguments as list
+    """
+
+    def __init__(self, args: List[Any] = None):
+        self._args = args if args is not None else []
+
+    def get(self, index: int, default: Any = None) -> Any:
+        """Get argument at index, returns default if not found"""
+        if 0 <= index < len(self._args):
+            return self._args[index]
+        return default
+
+    def count(self) -> int:
+        """Return total number of arguments"""
+        return len(self._args)
+
+    def all(self) -> List[Any]:
+        """Return all arguments as a list"""
+        return list(self._args)
+
+    def has(self, index: int) -> bool:
+        """Check if argument exists at index"""
+        return 0 <= index < len(self._args)
+
+    def __iter__(self):
+        return iter(self._args)
+
+    def __len__(self):
+        return len(self._args)
+
+    def __getitem__(self, index: int) -> Any:
+        return self.get(index)
+
+
 def OpenFind(combo_or_type: Union[Combo, type], index: int = 0) -> Optional[Any]:
     """Find open parameter by type or combo space.
 
@@ -384,7 +427,12 @@ def create_openquote(db_ref: Any = None) -> OpenQuote:
 
 __all__ = [
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind',
+    'OpenFind', 'Parameter',
     'create_datastruct', 'create_shuffled', 'create_iterator',
-    'create_combo', 'create_dataspace', 'create_openquote'
+    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter'
 ]
+
+
+def create_parameter(args: List[Any] = None) -> Parameter:
+    """Create a Parameter object for accessing exec arguments"""
+    return Parameter(args)

includecpp/core/cssl_bridge.py

@@ -5,7 +5,105 @@ Provides CsslLang class for executing CSSL code from Python.
 
 import threading
 from pathlib import Path
-from typing import Any, List, Optional, Callable
+from typing import Any, List, Optional, Callable, Dict
+
+
+class CSSLModule:
+    """
+    A callable CSSL module that executes code with arguments.
+
+    Created via CSSL.module() - the code is executed each time the module is called,
+    with arguments accessible via parameter.get(index).
+    """
+
+    def __init__(self, cssl_instance: 'CsslLang', code: str):
+        self._cssl = cssl_instance
+        self._code = code
+
+    def __call__(self, *args) -> Any:
+        """Execute the module code with the given arguments."""
+        return self._cssl.exec(self._code, *args)
+
+    def __repr__(self) -> str:
+        return f"<CSSLModule code_len={len(self._code)}>"
+
+
+class CSSLFunctionModule:
+    """
+    A CSSL module with accessible functions as methods.
+
+    Created via CSSL.makemodule() - functions defined in the CSSL code
+    become callable attributes on this module.
+    """
+
+    def __init__(self, cssl_instance: 'CsslLang', code: str):
+        self._cssl = cssl_instance
+        self._code = code
+        self._runtime = None
+        self._functions: Dict[str, Any] = {}
+        self._initialized = False
+
+    def _ensure_initialized(self):
+        """Initialize the module by parsing and registering functions."""
+        if self._initialized:
+            return
+
+        from .cssl import CSSLRuntime, parse_cssl_program, ASTNode
+
+        # Create a dedicated runtime for this module
+        self._runtime = CSSLRuntime()
+
+        # Parse the code
+        ast = parse_cssl_program(self._code)
+
+        # Execute to register all function definitions
+        for child in ast.children:
+            if child.type == 'function':
+                func_info = child.value
+                func_name = func_info.get('name')
+                self._functions[func_name] = child
+                self._runtime.scope.set(func_name, child)
+            else:
+                # Execute other statements (like struct definitions)
+                try:
+                    self._runtime._execute_node(child)
+                except Exception:
+                    pass
+
+        self._initialized = True
+
+    def __getattr__(self, name: str) -> Callable:
+        """Get a function from the module."""
+        # Avoid recursion for internal attributes
+        if name.startswith('_'):
+            raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'")
+
+        self._ensure_initialized()
+
+        if name in self._functions:
+            func_node = self._functions[name]
+
+            def wrapper(*args):
+                from .cssl import Parameter
+                # Set up parameter object for this call
+                self._runtime.global_scope.set('parameter', Parameter(list(args)))
+                self._runtime.global_scope.set('args', list(args))
+                self._runtime.global_scope.set('argc', len(args))
+                return self._runtime._call_function(func_node, list(args))
+
+            return wrapper
+
+        raise AttributeError(f"CSSL module has no function '{name}'")
+
+    def __dir__(self) -> List[str]:
+        """List available functions."""
+        self._ensure_initialized()
+        return list(self._functions.keys())
+
+    def __repr__(self) -> str:
+        self._ensure_initialized()
+        funcs = ', '.join(self._functions.keys())
+        return f"<CSSLFunctionModule functions=[{funcs}]>"
 
 
 class CsslLang:
@@ -58,8 +156,10 @@ class CsslLang:
             source = path_or_code
 
         # Set arguments in runtime scope
+        from .cssl import Parameter
         runtime.global_scope.set('args', list(args))
         runtime.global_scope.set('argc', len(args))
+        runtime.global_scope.set('parameter', Parameter(list(args)))
 
         # Execute as standalone program
         try:
@@ -120,6 +220,53 @@ class CsslLang:
         runtime = self._get_runtime()
         return runtime.global_scope.get(name)
 
+    def module(self, code: str) -> 'CSSLModule':
+        """
+        Create a callable CSSL module from code.
+
+        The module can be called with arguments that are passed to the CSSL code.
+
+        Usage:
+            module = CSSL.module('''
+                printl(parameter.get(0));
+            ''')
+            module("Hello")  # Prints "Hello"
+
+        Args:
+            code: CSSL code string
+
+        Returns:
+            CSSLModule - a callable module
+        """
+        return CSSLModule(self, code)
+
+    def makemodule(self, code: str) -> 'CSSLFunctionModule':
+        """
+        Create a CSSL module with accessible functions.
+
+        Functions defined in the code become methods on the returned module.
+
+        Usage:
+            module = CSSL.makemodule('''
+                string greet(string name) {
+                    return "Hello, " + name + "!";
+                }
+
+                int add(int a, int b) {
+                    return a + b;
+                }
+            ''')
+            module.greet("World")  # Returns "Hello, World!"
+            module.add(2, 3)       # Returns 5
+
+        Args:
+            code: CSSL code string with function definitions
+
+        Returns:
+            CSSLFunctionModule - module with callable function attributes
+        """
+        return CSSLFunctionModule(self, code)
+
 
 # Singleton for convenience
 _default_instance: Optional[CsslLang] = None
@@ -130,3 +277,133 @@ def get_cssl() -> CsslLang:
     if _default_instance is None:
         _default_instance = CsslLang()
     return _default_instance
+
+
+# Module-level convenience functions
+def exec(path_or_code: str, *args) -> Any:
+    """
+    Execute CSSL code or file.
+
+    Usage:
+        from includecpp import CSSL
+        CSSL.exec("script.cssl", arg1, arg2)
+        CSSL.exec("printl('Hello World');")
+
+    Args:
+        path_or_code: Path to .cssl file or CSSL code string
+        *args: Arguments to pass to the script
+
+    Returns:
+        Execution result
+    """
+    return get_cssl().exec(path_or_code, *args)
+
+
+def T_exec(path_or_code: str, *args, callback: Optional[Callable[[Any], None]] = None) -> threading.Thread:
+    """
+    Execute CSSL code asynchronously in a thread.
+
+    Usage:
+        from includecpp import CSSL
+        CSSL.T_exec("async_script.cssl", arg1, callback=on_done)
+
+    Args:
+        path_or_code: Path to .cssl file or CSSL code string
+        *args: Arguments to pass to the script
+        callback: Optional callback when execution completes
+
+    Returns:
+        Thread object
+    """
+    return get_cssl().T_exec(path_or_code, *args, callback=callback)
+
+
+def set_global(name: str, value: Any) -> None:
+    """Set a global variable in CSSL runtime."""
+    get_cssl().set_global(name, value)
+
+
+def get_global(name: str) -> Any:
+    """Get a global variable from CSSL runtime."""
+    return get_cssl().get_global(name)
+
+
+def get_output() -> List[str]:
+    """Get output buffer from last execution."""
+    return get_cssl().get_output()
+
+
+def clear_output() -> None:
+    """Clear output buffer."""
+    get_cssl().clear_output()
+
+
+# Aliases to avoid conflict with Python builtin exec
+_exec = exec
+_T_exec = T_exec
+
+
+def module(code: str) -> CSSLModule:
+    """
+    Create a callable CSSL module from code.
+
+    Usage:
+        from includecpp import CSSL
+        greet = CSSL.module('''
+            printl("Hello, " + parameter.get(0) + "!");
+        ''')
+        greet("World")  # Prints "Hello, World!"
+
+    Args:
+        code: CSSL code string
+
+    Returns:
+        CSSLModule - a callable module
+    """
+    return get_cssl().module(code)
+
+
+def makemodule(code: str) -> CSSLFunctionModule:
+    """
+    Create a CSSL module with accessible functions.
+
+    Usage:
+        from includecpp import CSSL
+        math_mod = CSSL.makemodule('''
+            int add(int a, int b) {
+                return a + b;
+            }
+
+            int multiply(int a, int b) {
+                return a * b;
+            }
+        ''')
+        math_mod.add(2, 3)       # Returns 5
+        math_mod.multiply(4, 5)  # Returns 20
+
+    Args:
+        code: CSSL code string with function definitions
+
+    Returns:
+        CSSLFunctionModule - module with callable function attributes
+    """
+    return get_cssl().makemodule(code)
+
+
+# Export all
+__all__ = [
+    'CsslLang',
+    'CSSLModule',
+    'CSSLFunctionModule',
+    'get_cssl',
+    'exec',
+    '_exec',  # Alias for exec (avoids Python builtin conflict)
+    'T_exec',
+    '_T_exec',  # Alias for T_exec
+    'set_global',
+    'get_global',
+    'get_output',
+    'clear_output',
+    'module',
+    'makemodule',
+]

includecpp/core/cssl_bridge.pyi

@@ -0,0 +1,311 @@
+"""
+CSSL Bridge - Type Stubs for Python API
+"""
+
+import threading
+from typing import Any, List, Optional, Callable, Dict
+
+
+class CSSLModule:
+    """
+    A callable CSSL module that executes code with arguments.
+
+    Created via CSSL.module() - the code is executed each time the module is called,
+    with arguments accessible via parameter.get(index).
+    """
+
+    def __init__(self, cssl_instance: 'CsslLang', code: str) -> None: ...
+    def __call__(self, *args: Any) -> Any:
+        """Execute the module code with the given arguments."""
+        ...
+    def __repr__(self) -> str: ...
+
+
+class CSSLFunctionModule:
+    """
+    A CSSL module with accessible functions as methods.
+
+    Created via CSSL.makemodule() - functions defined in the CSSL code
+    become callable attributes on this module.
+    """
+
+    def __init__(self, cssl_instance: 'CsslLang', code: str) -> None: ...
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        """Get a function from the module."""
+        ...
+    def __dir__(self) -> List[str]:
+        """List available functions."""
+        ...
+    def __repr__(self) -> str: ...
+
+
+class CsslLang:
+    """
+    CSSL Language interface for Python.
+
+    Usage:
+        from includecpp import CSSL
+        cssl = CSSL.CsslLang()
+        result = cssl.exec("script.cssl", arg1, arg2)
+        cssl.T_exec("async_script.cssl", arg1)  # Threaded
+    """
+
+    def __init__(self, output_callback: Optional[Callable[[str, str], None]] = ...) -> None:
+        """
+        Initialize CSSL runtime.
+
+        Args:
+            output_callback: Optional callback for output (text, level)
+        """
+        ...
+
+    def exec(self, path_or_code: str, *args: Any) -> Any:
+        """
+        Execute CSSL code or file.
+
+        Args:
+            path_or_code: Path to .cssl file or CSSL code string
+            *args: Arguments to pass to the script
+
+        Returns:
+            Execution result
+        """
+        ...
+
+    def T_exec(
+        self,
+        path_or_code: str,
+        *args: Any,
+        callback: Optional[Callable[[Any], None]] = ...
+    ) -> threading.Thread:
+        """
+        Execute CSSL code asynchronously in a thread.
+
+        Args:
+            path_or_code: Path to .cssl file or CSSL code string
+            *args: Arguments to pass to the script
+            callback: Optional callback when execution completes
+
+        Returns:
+            Thread object
+        """
+        ...
+
+    def wait_all(self, timeout: Optional[float] = ...) -> None:
+        """Wait for all async executions to complete."""
+        ...
+
+    def get_output(self) -> List[str]:
+        """Get output buffer from last execution."""
+        ...
+
+    def clear_output(self) -> None:
+        """Clear output buffer."""
+        ...
+
+    def set_global(self, name: str, value: Any) -> None:
+        """Set a global variable in CSSL runtime."""
+        ...
+
+    def get_global(self, name: str) -> Any:
+        """Get a global variable from CSSL runtime."""
+        ...
+
+    def module(self, code: str) -> CSSLModule:
+        """
+        Create a callable CSSL module from code.
+
+        Usage:
+            module = cssl.module('''
+                printl(parameter.get(0));
+            ''')
+            module("Hello")  # Prints "Hello"
+
+        Args:
+            code: CSSL code string
+
+        Returns:
+            CSSLModule - a callable module
+        """
+        ...
+
+    def makemodule(self, code: str) -> CSSLFunctionModule:
+        """
+        Create a CSSL module with accessible functions.
+
+        Usage:
+            module = cssl.makemodule('''
+                string greet(string name) {
+                    return "Hello, " + name + "!";
+                }
+            ''')
+            module.greet("World")  # Returns "Hello, World!"
+
+        Args:
+            code: CSSL code string with function definitions
+
+        Returns:
+            CSSLFunctionModule - module with callable function attributes
+        """
+        ...
+
+
+def get_cssl() -> CsslLang:
+    """Get default CSSL instance."""
+    ...
+
+
+def exec(path_or_code: str, *args: Any) -> Any:
+    """
+    Execute CSSL code or file.
+
+    Usage:
+        from includecpp import CSSL
+        CSSL.exec("script.cssl", arg1, arg2)
+        CSSL.exec("printl('Hello World');")
+
+    Args:
+        path_or_code: Path to .cssl file or CSSL code string
+        *args: Arguments to pass to the script
+
+    Returns:
+        Execution result
+    """
+    ...
+
+
+def T_exec(
+    path_or_code: str,
+    *args: Any,
+    callback: Optional[Callable[[Any], None]] = ...
+) -> threading.Thread:
+    """
+    Execute CSSL code asynchronously in a thread.
+
+    Usage:
+        from includecpp import CSSL
+        CSSL.T_exec("async_script.cssl", arg1, callback=on_done)
+
+    Args:
+        path_or_code: Path to .cssl file or CSSL code string
+        *args: Arguments to pass to the script
+        callback: Optional callback when execution completes
+
+    Returns:
+        Thread object
+    """
+    ...
+
+
+def set_global(name: str, value: Any) -> None:
+    """Set a global variable in CSSL runtime."""
+    ...
+
+
+def get_global(name: str) -> Any:
+    """Get a global variable from CSSL runtime."""
+    ...
+
+
+def get_output() -> List[str]:
+    """Get output buffer from last execution."""
+    ...
+
+
+def clear_output() -> None:
+    """Clear output buffer."""
+    ...
+
+
+# Aliases to avoid conflict with Python builtin exec
+def _exec(code: str, *args: Any) -> Any:
+    """
+    Execute CSSL code directly (alias for exec).
+
+    Supports triple-quoted docstrings for inline CSSL code:
+
+    Usage:
+        from includecpp import CSSL
+        CSSL._exec('''
+            global base = include("abc.cssl-mod");
+
+            void TestFunc() {
+                printl("hey");
+                @base.RechneWas(4, 5);
+            }
+
+            TestFunc();
+        ''')
+
+    Args:
+        code: CSSL code string (supports triple-quoted docstrings)
+        *args: Arguments to pass to the script
+
+    Returns:
+        Execution result
+    """
+    ...
+
+
+def _T_exec(
+    code: str,
+    *args: Any,
+    callback: Optional[Callable[[Any], None]] = ...
+) -> threading.Thread:
+    """
+    Execute CSSL code asynchronously in a thread (alias for T_exec).
+
+    Args:
+        code: CSSL code string
+        *args: Arguments to pass to the script
+        callback: Optional callback when execution completes
+
+    Returns:
+        Thread object
+    """
+    ...
+
+
+def module(code: str) -> CSSLModule:
+    """
+    Create a callable CSSL module from code.
+
+    Usage:
+        from includecpp import CSSL
+        greet = CSSL.module('''
+            printl("Hello, " + parameter.get(0) + "!");
+        ''')
+        greet("World")  # Prints "Hello, World!"
+
+    Args:
+        code: CSSL code string
+
+    Returns:
+        CSSLModule - a callable module
+    """
+    ...
+
+
+def makemodule(code: str) -> CSSLFunctionModule:
+    """
+    Create a CSSL module with accessible functions.
+
+    Usage:
+        from includecpp import CSSL
+        math_mod = CSSL.makemodule('''
+            int add(int a, int b) {
+                return a + b;
+            }
+        ''')
+        math_mod.add(2, 3)  # Returns 5
+
+    Args:
+        code: CSSL code string with function definitions
+
+    Returns:
+        CSSLFunctionModule - module with callable function attributes
+    """
+    ...
+
+
+__all__: List[str]

{includecpp-3.4.2.dist-info → includecpp-3.4.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.4.2
+Version: 3.4.8
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt