IncludeCPP 3.7.9__py3-none-any.whl → 3.7.25__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -19,6 +19,45 @@ from .cssl_types import (
 )
 
 
+# Global custom filter registry
+# Structure: { "type::helper": callback_function }
+# Callback signature: (source, filter_value, runtime) -> Any
+_custom_filters: Dict[str, Callable[[Any, Any, Any], Any]] = {}
+
+
+def register_filter(filter_type: str, helper: str, callback: Callable[[Any, Any, Any], Any]) -> None:
+    """Register a custom filter.
+
+    Args:
+        filter_type: The filter type (e.g., "mytype")
+        helper: The helper name (e.g., "where", "index", or "*" for catch-all)
+        callback: Function(source, filter_value, runtime) -> filtered_result
+
+    Usage in CSSL:
+        result <==[mytype::where="value"] source;
+
+    Usage from Python:
+        from includecpp.core.cssl.cssl_runtime import register_filter
+        register_filter("mytype", "where", lambda src, val, rt: ...)
+    """
+    key = f"{filter_type}::{helper}"
+    _custom_filters[key] = callback
+
+
+def unregister_filter(filter_type: str, helper: str) -> bool:
+    """Unregister a custom filter."""
+    key = f"{filter_type}::{helper}"
+    if key in _custom_filters:
+        del _custom_filters[key]
+        return True
+    return False
+
+
+def get_custom_filters() -> Dict[str, Callable]:
+    """Get all registered custom filters."""
+    return _custom_filters.copy()
+
+
 class CSSLRuntimeError(Exception):
     """Runtime error during CSSL execution with detailed context"""
     def __init__(self, message: str, line: int = 0, context: str = None, hint: str = None):
@@ -791,8 +830,18 @@ class CSSLRuntime:
                 if hasattr(instance, 'append'):
                     instance.append(init_value)
 
+        # Check for global modifier
+        modifiers = decl.get('modifiers', [])
+        is_global = 'global' in modifiers
+
         # Store in scope
         self.scope.set(var_name, instance)
+
+        # If global, also store in promoted_globals and global_scope
+        if is_global:
+            self._promoted_globals[var_name] = instance
+            self.global_scope.set(var_name, instance)
+
         return instance
 
     def _exec_instance_declaration(self, node: ASTNode) -> Any:
@@ -939,6 +988,14 @@ class CSSLRuntime:
             result = self._evaluate(inner.value)
             return result
 
+        # Handle typed declaration: global datastruct<int> data;
+        elif inner.type == 'typed_declaration':
+            # Add global modifier to the declaration
+            if isinstance(inner.value, dict):
+                inner.value['modifiers'] = inner.value.get('modifiers', []) + ['global']
+            result = self._exec_typed_declaration(inner)
+            return result
+
         # Fallback: execute normally
         return self._execute_node(inner)
 
@@ -1274,8 +1331,11 @@ class CSSLRuntime:
 
         return command_name
 
-    def _apply_injection_filter(self, source: Any, filter_info: dict) -> Any:
-        """Apply injection filter to extract specific data from source.
+    def _apply_injection_filter(self, source: Any, filter_info) -> Any:
+        """Apply injection filter(s) to extract specific data from source.
+
+        Supports both single filter dict and list of filter dicts for chained filters.
+        Example: [dynamic::content=10][dynamic::content=100] applies both filters.
 
         All BruteInjector Helpers:
         - string::where=VALUE - Filter strings containing VALUE
@@ -1292,10 +1352,31 @@ class CSSLRuntime:
         - combo::blocked - Get blocked items from combo
         - dynamic::VarName=VALUE - Filter by dynamic variable value
         - sql::data - Return only SQL-compatible data
+        - instance::class - Get classes from object
+        - instance::method - Get methods from object
+        - instance::var - Get variables from object
+        - instance::all - Get all categorized (methods, classes, vars)
+        - instance::"ClassName" - Get specific class by name
+        - name::"Name" - Filter by name (class, dict key, attribute)
         """
         if not filter_info:
             return source
 
+        # Handle list of filters (chained filters)
+        if isinstance(filter_info, list):
+            result = source
+            for single_filter in filter_info:
+                result = self._apply_single_filter(result, single_filter)
+            return result
+
+        # Single filter (dict)
+        return self._apply_single_filter(source, filter_info)
+
+    def _apply_single_filter(self, source: Any, filter_info: dict) -> Any:
+        """Apply a single injection filter to extract specific data from source."""
+        if not filter_info:
+            return source
+
         result = source
 
         for filter_key, filter_value in filter_info.items():
@@ -1303,6 +1384,18 @@ class CSSLRuntime:
                 filter_type, helper = filter_key.split('::', 1)
                 filter_val = self._evaluate(filter_value) if isinstance(filter_value, ASTNode) else filter_value
 
+                # === CHECK CUSTOM FILTERS FIRST ===
+                custom_key = f"{filter_type}::{helper}"
+                if custom_key in _custom_filters:
+                    result = _custom_filters[custom_key](result, filter_val, self)
+                    continue
+
+                # Check for catch-all custom filter (type::*)
+                catchall_key = f"{filter_type}::*"
+                if catchall_key in _custom_filters:
+                    result = _custom_filters[catchall_key](result, filter_val, self)
+                    continue
+
                 # === STRING HELPERS ===
                 if filter_type == 'string':
                     if helper == 'where':
@@ -1479,13 +1572,112 @@ class CSSLRuntime:
 
                 # === DYNAMIC HELPERS ===
                 elif filter_type == 'dynamic':
-                    # dynamic::VarName=VALUE - Match if variable equals value
-                    var_name = helper
-                    var_value = self.scope.get(var_name)
-                    if var_value == filter_val:
-                        pass  # Keep result
+                    if helper == 'content':
+                        # dynamic::content=VALUE - General content filter for any type
+                        # Filters elements where content equals VALUE
+                        if isinstance(result, (list, tuple)):
+                            # Filter list/tuple elements by content value
+                            result = [item for item in result if item == filter_val]
+                        elif isinstance(result, dict):
+                            # Filter dict by values matching filter_val
+                            result = {k: v for k, v in result.items() if v == filter_val}
+                        elif result == filter_val:
+                            pass  # Keep result if it matches
+                        else:
+                            result = None
+                    elif helper == 'not':
+                        # dynamic::not=VALUE - Exclude elements equal to VALUE
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item != filter_val]
+                        elif isinstance(result, dict):
+                            result = {k: v for k, v in result.items() if v != filter_val}
+                        elif result != filter_val:
+                            pass  # Keep result if it doesn't match
+                        else:
+                            result = None
+                    elif helper == 'gt':
+                        # dynamic::gt=VALUE - Greater than
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item > filter_val]
+                        elif result > filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'lt':
+                        # dynamic::lt=VALUE - Less than
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item < filter_val]
+                        elif result < filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'gte':
+                        # dynamic::gte=VALUE - Greater than or equal
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item >= filter_val]
+                        elif result >= filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'lte':
+                        # dynamic::lte=VALUE - Less than or equal
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item <= filter_val]
+                        elif result <= filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'mod':
+                        # dynamic::mod=VALUE - Modulo filter (item % VALUE == 0)
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, (int, float)) and item % filter_val == 0]
+                        elif isinstance(result, (int, float)) and result % filter_val == 0:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'range':
+                        # dynamic::range="min:max" - Filter values in range
+                        if isinstance(filter_val, str) and ':' in filter_val:
+                            parts = filter_val.split(':')
+                            min_val = int(parts[0]) if parts[0] else None
+                            max_val = int(parts[1]) if parts[1] else None
+                            if isinstance(result, (list, tuple)):
+                                def in_range(x):
+                                    if min_val is not None and x < min_val:
+                                        return False
+                                    if max_val is not None and x > max_val:
+                                        return False
+                                    return True
+                                result = [item for item in result if in_range(item)]
+                            elif isinstance(result, (int, float)):
+                                if min_val is not None and result < min_val:
+                                    result = None
+                                elif max_val is not None and result > max_val:
+                                    result = None
+                    elif helper == 'even':
+                        # dynamic::even - Filter even numbers
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, int) and item % 2 == 0]
+                        elif isinstance(result, int) and result % 2 == 0:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'odd':
+                        # dynamic::odd - Filter odd numbers
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, int) and item % 2 != 0]
+                        elif isinstance(result, int) and result % 2 != 0:
+                            pass
+                        else:
+                            result = None
                     else:
-                        result = None
+                        # dynamic::VarName=VALUE - Match if variable equals value
+                        var_name = helper
+                        var_value = self.scope.get(var_name)
+                        if var_value == filter_val:
+                            pass  # Keep result
+                        else:
+                            result = None
 
                 # === SQL HELPERS ===
                 elif filter_type == 'sql':
@@ -1496,6 +1688,128 @@ class CSSLRuntime:
                         else:
                             result = str(result)  # Convert to string
 
+                # === INSTANCE HELPERS ===
+                # Works on CSSLInstance, Python objects, dicts, modules
+                elif filter_type == 'instance':
+                    from .cssl_types import CSSLInstance
+                    import inspect
+
+                    if isinstance(result, CSSLInstance):
+                        # Filter CSSL instances
+                        if helper in ('class', 'classes'):
+                            classes = {}
+                            for name, member in result._members.items():
+                                if isinstance(member, CSSLInstance):
+                                    classes[name] = member
+                            result = classes if classes else None
+                        elif helper in ('method', 'methods'):
+                            result = dict(result._class.methods)
+                        elif helper in ('var', 'vars', 'variable', 'variables'):
+                            vars_dict = {}
+                            for name, member in result._members.items():
+                                if not isinstance(member, CSSLInstance):
+                                    vars_dict[name] = member
+                            result = vars_dict
+                        elif helper in ('all',):
+                            result = {
+                                'methods': list(result._class.methods.keys()),
+                                'classes': [result._class.name] + [m._class.name for m in result._members.values() if isinstance(m, CSSLInstance)],
+                                'vars': [n for n, m in result._members.items() if not isinstance(m, CSSLInstance)]
+                            }
+                        else:
+                            # Filter by class name
+                            class_name = filter_val if filter_val else helper
+                            found = None
+                            if result._class.name == class_name:
+                                found = result
+                            else:
+                                for name, member in result._members.items():
+                                    if isinstance(member, CSSLInstance) and member._class.name == class_name:
+                                        found = member
+                                        break
+                            result = found
+                    elif isinstance(result, dict):
+                        # Filter dicts
+                        if helper in ('class', 'classes'):
+                            result = {k: v for k, v in result.items() if inspect.isclass(v)}
+                        elif helper in ('method', 'methods', 'func', 'function', 'functions'):
+                            result = {k: v for k, v in result.items() if callable(v)}
+                        elif helper in ('var', 'vars', 'variable', 'variables'):
+                            result = {k: v for k, v in result.items() if not callable(v) and not inspect.isclass(v)}
+                        else:
+                            # Get by key
+                            key_name = filter_val if filter_val else helper
+                            result = result.get(key_name)
+                    elif hasattr(result, '__dict__') or hasattr(result, '__class__'):
+                        # Filter Python objects/modules
+                        if helper in ('class', 'classes'):
+                            classes = {}
+                            for name in dir(result):
+                                if not name.startswith('_'):
+                                    attr = getattr(result, name, None)
+                                    if inspect.isclass(attr):
+                                        classes[name] = attr
+                            result = classes if classes else None
+                        elif helper in ('method', 'methods', 'func', 'function', 'functions'):
+                            methods = {}
+                            for name in dir(result):
+                                if not name.startswith('_'):
+                                    attr = getattr(result, name, None)
+                                    if callable(attr):
+                                        methods[name] = attr
+                            result = methods if methods else None
+                        elif helper in ('var', 'vars', 'variable', 'variables'):
+                            vars_dict = {}
+                            for name in dir(result):
+                                if not name.startswith('_'):
+                                    attr = getattr(result, name, None)
+                                    if not callable(attr) and not inspect.isclass(attr):
+                                        vars_dict[name] = attr
+                            result = vars_dict if vars_dict else None
+                        elif helper in ('all',):
+                            all_info = {'methods': [], 'classes': [], 'vars': []}
+                            for name in dir(result):
+                                if not name.startswith('_'):
+                                    attr = getattr(result, name, None)
+                                    if inspect.isclass(attr):
+                                        all_info['classes'].append(name)
+                                    elif callable(attr):
+                                        all_info['methods'].append(name)
+                                    else:
+                                        all_info['vars'].append(name)
+                            result = all_info
+                        else:
+                            # Get attribute by name
+                            attr_name = filter_val if filter_val else helper
+                            result = getattr(result, attr_name, None)
+
+                # === NAME HELPERS ===
+                # General name filter for any object type
+                elif filter_type == 'name':
+                    from .cssl_types import CSSLInstance
+                    target_name = filter_val if filter_val else helper
+
+                    if isinstance(result, CSSLInstance):
+                        if result._class.name == target_name:
+                            pass  # Keep result
+                        else:
+                            found = None
+                            for name, member in result._members.items():
+                                if isinstance(member, CSSLInstance) and member._class.name == target_name:
+                                    found = member
+                                    break
+                            result = found
+                    elif isinstance(result, dict):
+                        result = result.get(target_name)
+                    elif isinstance(result, list):
+                        result = [item for item in result if str(item) == target_name or (hasattr(item, 'name') and item.name == target_name)]
+                    elif hasattr(result, target_name):
+                        result = getattr(result, target_name)
+                    elif hasattr(result, '__class__') and result.__class__.__name__ == target_name:
+                        pass  # Keep result if class name matches
+                    else:
+                        result = None
+
         return result
 
     def _exec_inject(self, node: ASTNode) -> Any:
@@ -1553,7 +1867,15 @@ class CSSLRuntime:
             final_value = source
         elif mode == 'add':
             # Copy & add - preserve target and add source
-            if isinstance(current_value, list):
+            from .cssl_types import CSSLInstance
+
+            # Special handling for CSSLInstance - merge classes
+            if isinstance(current_value, CSSLInstance) and isinstance(source, CSSLInstance):
+                # Add the new class instance as a member with class name as key
+                class_name = source._class.name
+                current_value._members[class_name] = source
+                final_value = current_value
+            elif isinstance(current_value, list):
                 if isinstance(source, list):
                     final_value = current_value + source
                 else:
@@ -1569,9 +1891,14 @@ class CSSLRuntime:
         elif mode == 'move':
             # Move & remove from source
             final_value = source
-            # Clear the source
-            if isinstance(source_node, ASTNode) and source_node.type == 'identifier':
-                self.scope.set(source_node.value, None)
+            # Clear the source - handle all node types
+            if isinstance(source_node, ASTNode):
+                if source_node.type == 'identifier':
+                    self.scope.set(source_node.value, None)
+                elif source_node.type == 'module_ref':
+                    self._set_module_value(source_node.value, None)
+                elif source_node.type == 'member_access':
+                    self._set_member(source_node, None)
         else:
             final_value = source
 
@@ -1643,9 +1970,36 @@ class CSSLRuntime:
                 final_value = [current_value, source]
         elif mode == 'move':
             final_value = source
-            # Clear the source
-            if isinstance(source_node, ASTNode) and source_node.type == 'identifier':
-                self.scope.set(source_node.value, None)
+            # Remove filtered elements from source (not clear entirely)
+            if isinstance(source_node, ASTNode):
+                if filter_info:
+                    # Get original source value
+                    original_source = self._evaluate(source_node)
+                    if isinstance(original_source, list) and isinstance(final_value, list):
+                        # Remove filtered items from original list
+                        remaining = [item for item in original_source if item not in final_value]
+                        if source_node.type == 'identifier':
+                            self.scope.set(source_node.value, remaining)
+                        elif source_node.type == 'module_ref':
+                            self._set_module_value(source_node.value, remaining)
+                        elif source_node.type == 'member_access':
+                            self._set_member(source_node, remaining)
+                    else:
+                        # Single value filter - set source to None
+                        if source_node.type == 'identifier':
+                            self.scope.set(source_node.value, None)
+                        elif source_node.type == 'module_ref':
+                            self._set_module_value(source_node.value, None)
+                        elif source_node.type == 'member_access':
+                            self._set_member(source_node, None)
+                else:
+                    # No filter - clear entire source
+                    if source_node.type == 'identifier':
+                        self.scope.set(source_node.value, None)
+                    elif source_node.type == 'module_ref':
+                        self._set_module_value(source_node.value, None)
+                    elif source_node.type == 'member_access':
+                        self._set_member(source_node, None)
         else:
             final_value = source
 
@@ -1668,6 +2022,42 @@ class CSSLRuntime:
             self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
         elif target.type == 'member_access':
             self._set_member(target, final_value)
+        elif target.type == 'typed_declaration':
+            # Handle typed target: source ==> datastruct<dynamic> Output
+            var_name = target.value.get('name')
+            type_name = target.value.get('type_name')
+            element_type = target.value.get('element_type', 'dynamic')
+
+            # Create appropriate container with final_value
+            from .cssl_types import (create_datastruct, create_vector, create_array,
+                                      create_stack, create_list, create_dictionary, create_map)
+
+            container = None
+            if type_name == 'datastruct':
+                container = create_datastruct(element_type)
+            elif type_name == 'vector':
+                container = create_vector(element_type)
+            elif type_name == 'array':
+                container = create_array(element_type)
+            elif type_name == 'stack':
+                container = create_stack(element_type)
+            elif type_name == 'list':
+                container = create_list(element_type)
+            elif type_name == 'dictionary':
+                container = create_dictionary()
+            elif type_name == 'map':
+                container = create_map()
+
+            if container is not None:
+                # Add final_value to container
+                if isinstance(final_value, (list, tuple)):
+                    container.extend(final_value)
+                elif final_value is not None:
+                    container.append(final_value)
+                self.scope.set(var_name, container)
+            else:
+                # Unknown type, just set the value directly
+                self.scope.set(var_name, final_value)
 
         return final_value
 
@@ -1860,6 +2250,10 @@ class CSSLRuntime:
         """Execute expression statement"""
         return self._evaluate(node.value)
 
+    def _exec_type_instantiation(self, node: ASTNode) -> Any:
+        """Execute type instantiation as statement (e.g., vector<int>)"""
+        return self._evaluate(node)
+
     def _exec_await(self, node: ASTNode) -> Any:
         """Execute await statement - waits for expression to complete"""
         # Evaluate the awaited expression
@@ -1941,12 +2335,13 @@ class CSSLRuntime:
             return value
 
         if node.type == 'module_ref':
-            # Check modules first, then promoted globals, then scope
-            value = self.get_module(node.value)
-            if value is None:
-                value = self._promoted_globals.get(node.value)
+            # User-defined globals have priority over SDK modules
+            # Check promoted globals first, then global scope, then SDK modules
+            value = self._promoted_globals.get(node.value)
             if value is None:
                 value = self.global_scope.get(node.value)
+            if value is None:
+                value = self.get_module(node.value)  # SDK modules as fallback
             return value
 
         if node.type == 'self_ref':
@@ -2030,12 +2425,28 @@ class CSSLRuntime:
             value_type = node.value.get('value_type')  # For map<K, V>
             init_values = node.value.get('init_values')  # For inline init: map<K,V>{...}
 
+            # Helper to populate container with init values
+            def _populate_container(container, init_vals):
+                if init_vals and isinstance(init_vals, list):
+                    for val_node in init_vals:
+                        val = self._evaluate(val_node) if isinstance(val_node, ASTNode) else val_node
+                        if hasattr(container, 'push'):
+                            container.push(val)
+                        elif hasattr(container, 'add'):
+                            container.add(val)
+                        elif hasattr(container, 'append'):
+                            container.append(val)
+                return container
+
             if type_name == 'stack':
-                return Stack(element_type)
+                s = Stack(element_type)
+                return _populate_container(s, init_values)
             elif type_name == 'vector':
-                return Vector(element_type)
+                v = Vector(element_type)
+                return _populate_container(v, init_values)
             elif type_name == 'datastruct':
-                return DataStruct(element_type)
+                d = DataStruct(element_type)
+                return _populate_container(d, init_values)
             elif type_name == 'shuffled':
                 return Shuffled(element_type)
             elif type_name == 'iterator':
@@ -2047,9 +2458,11 @@ class CSSLRuntime:
             elif type_name == 'openquote':
                 return OpenQuote()
             elif type_name == 'array':
-                return Array(element_type)
+                a = Array(element_type)
+                return _populate_container(a, init_values)
             elif type_name == 'list':
-                return List(element_type)
+                l = List(element_type)
+                return _populate_container(l, init_values)
             elif type_name in ('dictionary', 'dict'):
                 return Dictionary(element_type)
             elif type_name == 'map':
@@ -2836,12 +3249,20 @@ class CSSLRuntime:
                 pass
 
     def _set_module_value(self, path: str, value: Any):
-        """Set a value on a module path"""
+        """Set a value on a module path or promoted global"""
         parts = path.split('.')
         if len(parts) < 2:
+            # Single name (no dots) - set in promoted_globals and global_scope
+            self._promoted_globals[path] = value
+            self.global_scope.set(path, value)
             return
 
         obj = self._modules.get(parts[0])
+        # Also check promoted_globals for the base object
+        if obj is None:
+            obj = self._promoted_globals.get(parts[0])
+        if obj is None:
+            obj = self.global_scope.get(parts[0])
         if obj is None:
             return
 

includecpp/core/cssl/cssl_syntax.py

@@ -1,7 +1,7 @@
 """
 CSSL Syntax Highlighting
 
-Provides syntax highlighting for CSSL (CSO Service Script Language) code.
+Provides syntax highlighting for CSSL code.
 Can be used with:
 - PyQt5/6 QSyntaxHighlighter
 - VSCode/TextMate grammar export
@@ -216,8 +216,8 @@ class CSSLSyntaxRules:
 class ColorScheme:
     """Color scheme for syntax highlighting"""
 
-    # CSO Theme (Orange accent, dark background)
-    CSO_THEME = {
+    # CSSL Theme (Orange accent, dark background)
+    CSSL_THEME = {
         TokenCategory.KEYWORD: '#508cff',      # Blue
         TokenCategory.BUILTIN: '#ff8c00',      # Orange
         TokenCategory.OPERATOR: '#c8c8d2',     # Light gray
@@ -261,13 +261,13 @@ def highlight_cssl(source: str, scheme: Dict[TokenCategory, str] = None) -> List
 
     Args:
         source: CSSL source code
-        scheme: Color scheme dict (defaults to CSO_THEME)
+        scheme: Color scheme dict (defaults to CSSL_THEME)
 
     Returns:
         List of (start, end, color, category) tuples
     """
     if scheme is None:
-        scheme = ColorScheme.CSO_THEME
+        scheme = ColorScheme.CSSL_THEME
 
     highlights = []
     rules = CSSLSyntaxRules.get_rules()
@@ -337,7 +337,7 @@ def highlight_cssl_ansi(source: str) -> str:
     }
     RESET = '\033[0m'
 
-    highlights = highlight_cssl(source, ColorScheme.CSO_THEME)
+    highlights = highlight_cssl(source, ColorScheme.CSSL_THEME)
 
     # Build highlighted string
     result = []
@@ -388,7 +388,7 @@ def get_pyqt_highlighter():
 
         def _setup_rules(self):
             """Setup highlighting rules"""
-            scheme = ColorScheme.CSO_THEME
+            scheme = ColorScheme.CSSL_THEME
 
             for rule in CSSLSyntaxRules.get_rules():
                 fmt = QTextCharFormat()