IncludeCPP 3.4.22__tar.gz → 3.5.2__tar.gz

{includecpp-3.4.22 → includecpp-3.5.2}/IncludeCPP.egg-info/PKG-INFO

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

{includecpp-3.4.22 → includecpp-3.5.2}/PKG-INFO

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

{includecpp-3.4.22 → includecpp-3.5.2}/includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "3.4.22"
+__version__ = "3.5.2"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-3.4.22 → includecpp-3.5.2}/includecpp/cli/commands.py

@@ -7139,20 +7139,21 @@ def cppy_types():
 # EXEC - Interactive Code Execution
 # ============================================================================
 
-@cli.command()
-@click.argument('lang', type=click.Choice(['py', 'cpp', 'python', 'c++']))
+@cli.command(name='exec')
+@click.argument('lang', type=click.Choice(['py', 'cpp', 'python', 'c++', 'cssl']))
 @click.argument('path', required=False, type=click.Path())
 @click.option('--all', 'import_all', is_flag=True, help='Import all available modules')
-def exec(lang, path, import_all):
+def exec_repl(lang, path, import_all):
     """Execute code interactively for quick testing.
 
-    Run Python or C++ code snippets without creating files.
+    Run Python, C++ or CSSL code snippets without creating files.
     Perfect for testing your IncludeCPP modules quickly.
 
     \b
     Usage:
       includecpp exec py              # Interactive Python
       includecpp exec cpp             # Interactive C++
+      includecpp exec cssl            # Interactive CSSL
       includecpp exec py mymodule     # Auto-import mymodule
       includecpp exec py plugins/x.cp # Auto-import from plugin
       includecpp exec py --all        # Import all modules
@@ -7178,7 +7179,8 @@ def exec(lang, path, import_all):
 
     # Normalize language
     is_python = lang in ('py', 'python')
-    lang_name = 'Python' if is_python else 'C++'
+    is_cssl = lang == 'cssl'
+    lang_name = 'Python' if is_python else ('CSSL' if is_cssl else 'C++')
 
     # Build imports/includes
     imports = []
@@ -7286,6 +7288,7 @@ def exec(lang, path, import_all):
 
     if is_python:
         # Execute Python code
+        import builtins
         full_code = '\n'.join(code_lines)
         try:
             # Use exec with captured output
@@ -7299,7 +7302,7 @@ def exec(lang, path, import_all):
             exec_globals = {'__name__': '__main__'}
 
             with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
-                exec(full_code, exec_globals)
+                builtins.exec(full_code, exec_globals)
 
             stdout_val = stdout_capture.getvalue()
             stderr_val = stderr_capture.getvalue()
@@ -7315,6 +7318,29 @@ def exec(lang, path, import_all):
         except Exception as e:
             click.secho(f"Error: {e}", fg='red')
 
+    elif is_cssl:
+        # Execute CSSL code
+        full_code = '\n'.join(lines)
+        try:
+            from ..core.cssl_bridge import CsslLang
+            cssl_lang = CsslLang()
+            result = cssl_lang.exec(full_code)
+
+            # Print any output from the execution
+            output = cssl_lang.get_output()
+            if output:
+                for line in output:
+                    click.echo(line)
+
+            if result is not None:
+                click.echo(result)
+
+            if not output and result is None:
+                click.secho("(no output)", fg='bright_black')
+
+        except Exception as e:
+            click.secho(f"Error: {e}", fg='red')
+
     else:
         # Execute C++ code
         # Build a complete C++ program

{includecpp-3.4.22 → includecpp-3.5.2}/includecpp/core/cssl/cssl_builtins.py

@@ -1902,15 +1902,54 @@ class CSSLBuiltins:
         from .cssl_types import OpenQuote
         return OpenQuote(db_ref)
 
-    def builtin_openfind(self, combo_or_type: Any, index: int = 0) -> Any:
+    def builtin_openfind(self, combo_or_type: Any, index: int = 0, params: list = None) -> Any:
         """Find open parameter by type or combo space.
 
-        Usage: OpenFind<string>(0) or OpenFind(&@comboSpace)
+        Usage:
+            OpenFind<string>(0)  # Find first string at position 0
+            OpenFind(&@comboSpace)  # Find using combo filter
+
+        When using with open parameters:
+            open define myFunc(open Params) {
+                string name = OpenFind<string>(0);  // Find nearest string at index 0
+                int age = OpenFind<int>(1);  // Find nearest int at index 1
+            }
         """
         from .cssl_types import Combo
 
         if isinstance(combo_or_type, Combo):
+            # Find by combo space
+            if params:
+                return combo_or_type.find_match(params)
             return combo_or_type.find_match([])
+
+        # Type-based search
+        target_type = combo_or_type
+        if params is None:
+            params = []
+
+        # Map type names to Python types
+        type_map = {
+            'string': str, 'str': str,
+            'int': int, 'integer': int,
+            'float': float, 'double': float,
+            'bool': bool, 'boolean': bool,
+            'list': list, 'array': list,
+            'dict': dict, 'dictionary': dict
+        }
+
+        python_type = type_map.get(str(target_type).lower(), None)
+        if python_type is None:
+            return None
+
+        # Find the nearest matching type from index position
+        matches_found = 0
+        for i, param in enumerate(params):
+            if isinstance(param, python_type):
+                if matches_found == index:
+                    return param
+                matches_found += 1
+
         return None
 
 

{includecpp-3.4.22 → includecpp-3.5.2}/includecpp/core/cssl/cssl_parser.py

@@ -125,6 +125,7 @@ KEYWORDS = {
     'package', 'package-includes', 'exec', 'as', 'global',
     # CSSL Type Keywords
     'int', 'string', 'float', 'bool', 'void', 'json', 'array', 'vector', 'stack',
+    'list', 'dictionary', 'dict',  # Python-like types
     'dynamic',      # No type declaration (slow but flexible)
     'undefined',    # Function errors ignored
     'open',         # Accept any parameter type
@@ -152,7 +153,7 @@ TYPE_LITERALS = {'list', 'dict'}
 # Generic type keywords that use <T> syntax
 TYPE_GENERICS = {
     'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo',
-    'vector', 'stack', 'array', 'openquote'
+    'vector', 'stack', 'array', 'openquote', 'list', 'dictionary'
 }
 
 # Functions that accept type parameters: FuncName<type>(args)
@@ -660,6 +661,7 @@ class CSSLParser:
     def _is_type_keyword(self, value: str) -> bool:
         """Check if a keyword is a type declaration"""
         return value in ('int', 'string', 'float', 'bool', 'void', 'json', 'array', 'vector', 'stack',
+                        'list', 'dictionary', 'dict',
                         'dynamic', 'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo', 'structure')
 
     def _looks_like_function_declaration(self) -> bool:
@@ -877,7 +879,8 @@ class CSSLParser:
         # Skip known type keywords
         type_keywords = {'int', 'string', 'float', 'bool', 'dynamic', 'void',
                         'stack', 'vector', 'datastruct', 'dataspace', 'shuffled',
-                        'iterator', 'combo', 'array', 'openquote', 'json'}
+                        'iterator', 'combo', 'array', 'openquote', 'json',
+                        'list', 'dictionary', 'dict'}
         if type_name not in type_keywords:
             return False
 
@@ -1505,7 +1508,13 @@ class CSSLParser:
         return ASTNode('c_for_update', value={'var': var_name, 'op': 'none'})
 
     def _parse_python_style_for(self) -> ASTNode:
-        """Parse Python-style for loop: for (i in range(start, end)) { }"""
+        """Parse Python-style for loop: for (i in range(...)) { }
+
+        Supports:
+            for (i in range(n)) { }           - 0 to n-1
+            for (i in range(start, end)) { }  - start to end-1
+            for (i in range(start, end, step)) { }
+        """
         var_name = self._advance().value
         self._expect(TokenType.KEYWORD)  # 'in'
 
@@ -1518,15 +1527,27 @@ class CSSLParser:
             self.error(f"Expected 'range', got {self._peek().value}")
 
         self._expect(TokenType.PAREN_START)
-        start = self._parse_expression()
-        self._expect(TokenType.COMMA)
-        end = self._parse_expression()
+        first_arg = self._parse_expression()
 
-        # Optional step parameter: range(start, end, step)
+        # Check if there are more arguments
+        start = None
+        end = None
         step = None
+
         if self._check(TokenType.COMMA):
+            # range(start, end) or range(start, end, step)
             self._advance()  # consume comma
-            step = self._parse_expression()
+            start = first_arg
+            end = self._parse_expression()
+
+            # Optional step parameter
+            if self._check(TokenType.COMMA):
+                self._advance()  # consume comma
+                step = self._parse_expression()
+        else:
+            # range(n) - single argument means 0 to n-1
+            start = ASTNode('literal', value={'type': 'int', 'value': 0})
+            end = first_arg
 
         self._expect(TokenType.PAREN_END)
         self._expect(TokenType.PAREN_END)
@@ -1734,12 +1755,26 @@ class CSSLParser:
             self._match(TokenType.SEMICOLON)
             return ASTNode('inject', value={'target': expr, 'source': source, 'mode': 'add', 'filter': filter_info})
 
-        # === MINUS INJECTION: -<== (move & remove from source) ===
+        # === MINUS INJECTION: -<== or -<==[n] (move & remove from source) ===
         if self._match(TokenType.INJECT_MINUS_LEFT):
+            # Check for indexed deletion: -<==[n] (only numbers, not filters)
+            remove_index = None
+            if self._check(TokenType.BRACKET_START):
+                # Peek ahead to see if this is an index [n] or a filter [type::helper=...]
+                # Only consume if it's a simple number index
+                saved_pos = self._current
+                self._advance()  # consume [
+                if self._check(TokenType.NUMBER):
+                    remove_index = int(self._advance().value)
+                    self._expect(TokenType.BRACKET_END)
+                else:
+                    # Not a number - restore position for filter parsing
+                    self._current = saved_pos
+
             filter_info = self._parse_injection_filter()
             source = self._parse_expression()
             self._match(TokenType.SEMICOLON)
-            return ASTNode('inject', value={'target': expr, 'source': source, 'mode': 'move', 'filter': filter_info})
+            return ASTNode('inject', value={'target': expr, 'source': source, 'mode': 'move', 'filter': filter_info, 'index': remove_index})
 
         # === CODE INFUSION: <<== (inject code into function) ===
         if self._match(TokenType.INFUSE_LEFT):
@@ -1763,16 +1798,29 @@ class CSSLParser:
                 self._match(TokenType.SEMICOLON)
                 return ASTNode('infuse', value={'target': expr, 'source': source, 'mode': 'add'})
 
-        # === CODE INFUSION MINUS: -<<== (remove code from function) ===
+        # === CODE INFUSION MINUS: -<<== or -<<==[n] (remove code from function) ===
         if self._match(TokenType.INFUSE_MINUS_LEFT):
+            # Check for indexed deletion: -<<==[n] (only numbers)
+            remove_index = None
+            if self._check(TokenType.BRACKET_START):
+                # Peek ahead to see if this is an index [n] or something else
+                saved_pos = self._current
+                self._advance()  # consume [
+                if self._check(TokenType.NUMBER):
+                    remove_index = int(self._advance().value)
+                    self._expect(TokenType.BRACKET_END)
+                else:
+                    # Not a number - restore position
+                    self._current = saved_pos
+
             if self._check(TokenType.BLOCK_START):
                 code_block = self._parse_action_block()
                 self._match(TokenType.SEMICOLON)
-                return ASTNode('infuse', value={'target': expr, 'code': code_block, 'mode': 'remove'})
+                return ASTNode('infuse', value={'target': expr, 'code': code_block, 'mode': 'remove', 'index': remove_index})
             else:
                 source = self._parse_expression()
                 self._match(TokenType.SEMICOLON)
-                return ASTNode('infuse', value={'target': expr, 'source': source, 'mode': 'remove'})
+                return ASTNode('infuse', value={'target': expr, 'source': source, 'mode': 'remove', 'index': remove_index})
 
         # === RIGHT-SIDE OPERATORS ===
 

{includecpp-3.4.22 → includecpp-3.5.2}/includecpp/core/cssl/cssl_runtime.py

@@ -14,7 +14,7 @@ from .cssl_builtins import CSSLBuiltins
 from .cssl_modules import get_module_registry, get_standard_module
 from .cssl_types import (
     Parameter, DataStruct, Shuffled, Iterator, Combo,
-    Stack, Vector, Array, DataSpace, OpenQuote
+    Stack, Vector, Array, DataSpace, OpenQuote, List, Dictionary
 )
 
 
@@ -374,8 +374,13 @@ class CSSLRuntime:
         - top-level statements (assignments, function calls, control flow)
         """
         result = None
+        self._running = True  # Start running
 
         for child in node.children:
+            # Check if exit() was called
+            if not self._running:
+                break
+
             if child.type == 'struct':
                 self._exec_struct(child)
             elif child.type == 'function':
@@ -398,13 +403,14 @@ class CSSLRuntime:
                 except CSSLRuntimeError:
                     pass  # Ignore unknown nodes in program mode
 
-        # Look for and execute main() if defined
-        main_func = self.scope.get('main')
-        if main_func and isinstance(main_func, ASTNode) and main_func.type == 'function':
-            try:
-                result = self._call_function(main_func, [])
-            except CSSLReturn as ret:
-                result = ret.value
+        # Look for and execute main() if defined (only if still running)
+        if self._running:
+            main_func = self.scope.get('main')
+            if main_func and isinstance(main_func, ASTNode) and main_func.type == 'function':
+                try:
+                    result = self._call_function(main_func, [])
+                except CSSLReturn as ret:
+                    result = ret.value
 
         return result
 
@@ -701,6 +707,10 @@ class CSSLRuntime:
             instance = {} if value_node is None else self._evaluate(value_node)
         elif type_name == 'array':
             instance = Array(element_type)
+        elif type_name == 'list':
+            instance = List(element_type)
+        elif type_name in ('dictionary', 'dict'):
+            instance = Dictionary(element_type)
         else:
             # Default: evaluate the value or set to None
             instance = self._evaluate(value_node) if value_node else None
@@ -824,9 +834,11 @@ class CSSLRuntime:
 
     def _exec_while(self, node: ASTNode) -> Any:
         """Execute while loop"""
-        while self._evaluate(node.value.get('condition')):
+        while self._running and self._evaluate(node.value.get('condition')):
             try:
                 for child in node.children:
+                    if not self._running:
+                        break
                     self._execute_node(child)
             except CSSLBreak:
                 break
@@ -846,9 +858,13 @@ class CSSLRuntime:
         step = int(self._evaluate(step_node)) if step_node else 1
 
         for i in range(start, end, step):
+            if not self._running:
+                break
             self.scope.set(var_name, i)
             try:
                 for child in node.children:
+                    if not self._running:
+                        break
                     self._execute_node(child)
             except CSSLBreak:
                 break
@@ -879,7 +895,7 @@ class CSSLRuntime:
             var_name = None
 
         # Main loop
-        while True:
+        while self._running:
             # Check condition
             if condition:
                 cond_result = self._evaluate(condition)
@@ -890,6 +906,8 @@ class CSSLRuntime:
             # Execute body
             try:
                 for child in node.children:
+                    if not self._running:
+                        break
                     self._execute_node(child)
             except CSSLBreak:
                 break
@@ -933,9 +951,13 @@ class CSSLRuntime:
             return None
 
         for item in iterable:
+            if not self._running:
+                break
             self.scope.set(var_name, item)
             try:
                 for child in node.children:
+                    if not self._running:
+                        break
                     self._execute_node(child)
             except CSSLBreak:
                 break
@@ -1109,6 +1131,48 @@ class CSSLRuntime:
                             result = result if len(result) == filter_val else None
                         elif isinstance(result, list):
                             result = [item for item in result if isinstance(item, str) and len(item) == filter_val]
+                    elif helper == 'cut':
+                        # Cut string at given index - returns the part BEFORE the index
+                        # x = <==[string::cut=2] "20:200-1"  -->  x = "20"
+                        if isinstance(result, str):
+                            idx = int(filter_val) if not isinstance(filter_val, int) else filter_val
+                            result = result[:idx] if 0 <= idx <= len(result) else result
+                        elif isinstance(result, list):
+                            result = [item[:int(filter_val)] if isinstance(item, str) else item for item in result]
+                    elif helper == 'cutAfter':
+                        # Get the part AFTER the index
+                        # x = <==[string::cutAfter=2] "20:200-1"  -->  x = ":200-1"
+                        if isinstance(result, str):
+                            idx = int(filter_val) if not isinstance(filter_val, int) else filter_val
+                            result = result[idx:] if 0 <= idx <= len(result) else result
+                        elif isinstance(result, list):
+                            result = [item[int(filter_val):] if isinstance(item, str) else item for item in result]
+                    elif helper == 'slice':
+                        # Slice string with start:end format (e.g., "2:5")
+                        if isinstance(result, str) and isinstance(filter_val, str) and ':' in filter_val:
+                            parts = filter_val.split(':')
+                            start = int(parts[0]) if parts[0] else 0
+                            end = int(parts[1]) if parts[1] else len(result)
+                            result = result[start:end]
+                    elif helper == 'split':
+                        # Split string by delimiter
+                        if isinstance(result, str):
+                            result = result.split(str(filter_val))
+                    elif helper == 'replace':
+                        # Replace in string (format: "old:new")
+                        if isinstance(result, str) and isinstance(filter_val, str) and ':' in filter_val:
+                            parts = filter_val.split(':', 1)
+                            if len(parts) == 2:
+                                result = result.replace(parts[0], parts[1])
+                    elif helper == 'upper':
+                        if isinstance(result, str):
+                            result = result.upper()
+                    elif helper == 'lower':
+                        if isinstance(result, str):
+                            result = result.lower()
+                    elif helper == 'trim':
+                        if isinstance(result, str):
+                            result = result.strip()
 
                 # === INTEGER HELPERS ===
                 elif filter_type == 'integer':
@@ -1387,13 +1451,18 @@ class CSSLRuntime:
             self._function_injections[func_name] = [code_block]
             self._function_replaced[func_name] = True  # Mark as replaced
         elif mode == 'remove':
-            # -<<== : Remove matching code from function body
-            # For now, this removes all injections for the function
+            # -<<== or -<<==[n] : Remove matching code from function body
+            remove_index = node.value.get('index')
+
             if func_name in self._function_injections:
-                self._function_injections[func_name] = []
+                if remove_index is not None:
+                    # Indexed removal: -<<==[n] removes only the nth injection
+                    if 0 <= remove_index < len(self._function_injections[func_name]):
+                        self._function_injections[func_name].pop(remove_index)
+                else:
+                    # No index: -<<== removes all injections
+                    self._function_injections[func_name] = []
             self._function_replaced[func_name] = False
-            # Note: Removing from actual function body would require AST manipulation
-            # which is complex - for now we just clear injections
 
         return None
 
@@ -1608,6 +1677,10 @@ class CSSLRuntime:
                 return OpenQuote()
             elif type_name == 'array':
                 return Array(element_type)
+            elif type_name == 'list':
+                return List(element_type)
+            elif type_name in ('dictionary', 'dict'):
+                return Dictionary(element_type)
             else:
                 return None