IncludeCPP 3.7.21__py3-none-any.whl → 3.7.23__py3-none-any.whl

includecpp/__init__.py

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

includecpp/cli/commands.py

@@ -7720,7 +7720,13 @@ def cssl_doc(search, list_sections):
                     click.echo("Or use: includecpp cssl doc --list")
         else:
             # Full documentation mode
-            click.echo_via_pager(content)
+            # Replace Unicode characters that may not be supported on all terminals
+            safe_content = content.replace('✓', '[OK]').replace('✗', '[X]').replace('→', '->').replace('←', '<-').replace('•', '*').replace('─', '-').replace('│', '|').replace('└', '+').replace('├', '+').replace('▸', '>').replace('▾', 'v')
+            try:
+                click.echo_via_pager(safe_content)
+            except UnicodeEncodeError:
+                # Fallback: encode with errors='replace'
+                click.echo(safe_content.encode('ascii', errors='replace').decode('ascii'))
     else:
         click.secho("Documentation file not found.", fg='yellow')
         click.echo("Looking for: CSSL_DOCUMENTATION.md")

includecpp/core/cssl/cssl_parser.py

@@ -252,8 +252,15 @@ class CSSLLexer:
                 # $<name> shared object reference
                 self._read_shared_ref()
             elif char == '%':
-                # %<name> captured reference (for infusion)
-                self._read_captured_ref()
+                # Check if this is %<name> captured reference or % modulo operator
+                next_char = self._peek(1)
+                if next_char and (next_char.isalpha() or next_char == '_'):
+                    # %<name> captured reference (for infusion)
+                    self._read_captured_ref()
+                else:
+                    # % modulo operator
+                    self._add_token(TokenType.MODULO, '%')
+                    self._advance()
             elif char == '&':
                 # & for references
                 if self._peek(1) == '&':
@@ -321,9 +328,6 @@ class CSSLLexer:
                 else:
                     # Already handled by // comment check above, but just in case
                     self._skip_comment()
-            elif char == '%':
-                self._add_token(TokenType.MODULO, '%')
-                self._advance()
             elif char == '<':
                 self._read_less_than()
             elif char == '>':
@@ -1915,32 +1919,42 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
-    def _parse_injection_filter(self) -> Optional[dict]:
-        """Parse injection filter: [type::helper=value]"""
-        if not self._match(TokenType.BRACKET_START):
+    def _parse_injection_filter(self) -> Optional[list]:
+        """Parse injection filter(s): [type::helper=value] or [f1][f2][f3]...
+
+        Returns a list of filter dictionaries to support chained filters.
+        """
+        if not self._check(TokenType.BRACKET_START):
             return None
 
-        filter_info = {}
-        # Parse type::helper=value patterns
-        while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
-            if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
-                filter_type = self._advance().value
-                if self._match(TokenType.DOUBLE_COLON):
-                    helper = self._advance().value
-                    if self._match(TokenType.EQUALS):
-                        value = self._parse_expression()
-                        filter_info[f'{filter_type}::{helper}'] = value
+        filters = []
+
+        # Parse multiple consecutive filter brackets
+        while self._match(TokenType.BRACKET_START):
+            filter_info = {}
+            # Parse type::helper=value patterns within this bracket
+            while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
+                if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                    filter_type = self._advance().value
+                    if self._match(TokenType.DOUBLE_COLON):
+                        helper = self._advance().value
+                        if self._match(TokenType.EQUALS):
+                            value = self._parse_expression()
+                            filter_info[f'{filter_type}::{helper}'] = value
+                        else:
+                            filter_info[f'{filter_type}::{helper}'] = True
                     else:
-                        filter_info[f'{filter_type}::{helper}'] = True
+                        filter_info['type'] = filter_type
+                elif self._check(TokenType.COMMA):
+                    self._advance()
                 else:
-                    filter_info['type'] = filter_type
-            elif self._check(TokenType.COMMA):
-                self._advance()
-            else:
-                break
+                    break
 
-        self._expect(TokenType.BRACKET_END)
-        return filter_info if filter_info else None
+            self._expect(TokenType.BRACKET_END)
+            if filter_info:
+                filters.append(filter_info)
+
+        return filters if filters else None
 
     def _parse_expression_statement(self) -> Optional[ASTNode]:
         expr = self._parse_expression()

includecpp/core/cssl/cssl_runtime.py

@@ -1331,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
@@ -1359,6 +1362,21 @@ class CSSLRuntime:
         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():
@@ -1554,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':
@@ -1853,14 +1970,36 @@ class CSSLRuntime:
                 final_value = [current_value, source]
         elif mode == 'move':
             final_value = source
-            # Clear the source - handle all node types
+            # Remove filtered elements from source (not clear entirely)
             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)
+                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
 
@@ -1883,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
 

{includecpp-3.7.21.dist-info → includecpp-3.7.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.21
+Version: 3.7.23
 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.7.21.dist-info → includecpp-3.7.23.dist-info}/RECORD

@@ -1,9 +1,9 @@
-includecpp/__init__.py,sha256=hYkRPXgViZO8YrWxqA7IX284xwW81zMDqqjHUgMlOEM,1673
+includecpp/__init__.py,sha256=zlBkXO5fb20CjZcrm3aTHXIxpDg3fCujzh3dqpZHM8o,1673
 includecpp/__init__.pyi,sha256=uSDYlbqd2TinmrdepmE_zvN25jd3Co2cgyPzXgDpopM,7193
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 includecpp/cli/__init__.py,sha256=Yda-4a5QJb_tKu35YQNfc5lu-LewTsM5abqNNkzS47M,113
-includecpp/cli/commands.py,sha256=AeHirETVkzNqNcqh5RVO0ABPz_6gfuV2EpHcWK9BuDY,349032
+includecpp/cli/commands.py,sha256=HDoRuPEPTzxZQcR4rF45GrRVtcw3zDj6cGiwLCZB44Y,349597
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
 includecpp/core/ai_integration.py,sha256=PW6yFDqdXjfchpfKTKg59AOLhLry9kqJEGf_65BztrY,87603
@@ -25,8 +25,8 @@ includecpp/core/cssl/cssl_builtins.py,sha256=r-FX4WQeKxerkepqodIiwhtL_kxxa4PJym_
 includecpp/core/cssl/cssl_builtins.pyi,sha256=3ai2V4LyhzPBhAKjRRf0rLVu_bg9ECmTfTkdFKM64iA,127430
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
-includecpp/core/cssl/cssl_parser.py,sha256=SaFgehSB2300s4DtC_v1lmVyaBpg2jIRZcEeEiJ9E_o,115774
-includecpp/core/cssl/cssl_runtime.py,sha256=EETUsUOZL7PZ1a9Chz0JeJFP0w68DtSthoqSebigxrw,144834
+includecpp/core/cssl/cssl_parser.py,sha256=JJ5mKbKCgevOmShxSpEKpKzo79rjU2_qvnBfxsWlH_w,116431
+includecpp/core/cssl/cssl_runtime.py,sha256=iZgNcKDoTeV50-IsXcsrpuTyDPxEHWyQz5uR3s5UVHg,154613
 includecpp/core/cssl/cssl_syntax.py,sha256=bgo3NFehoPTQa5dqwNd_CstkVGVCNYAXbGYUcu5BEN0,16982
 includecpp/core/cssl/cssl_types.py,sha256=gVjtfxk0Uzfj-H7_LD79oqspFMYDf79ZrRrlZk8eAEs,50647
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
@@ -43,9 +43,9 @@ includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86
 includecpp/vscode/cssl/images/cssl_pl.png,sha256=z4WMk7g6YCTbUUbSFk343BO6yi_OmNEVYkRenWGydwM,799
 includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=l4SCEPR3CsPxA8HIVLKYY__I979TfKzYWtH1KYIsboo,33062
 includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=XKRLBOHlCqDDnGPvmNHDQPsIMR1UD9PBaJIlgZOiPqM,21173
-includecpp-3.7.21.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.7.21.dist-info/METADATA,sha256=3M6Vqu-_8hFmQBEst3XiQFaISZ70aTT2BGahWg-Bmpk,32122
-includecpp-3.7.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.7.21.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.7.21.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.7.21.dist-info/RECORD,,
+includecpp-3.7.23.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.7.23.dist-info/METADATA,sha256=v4tDVGdh6c2ejyc9w_gUj6LTa0kzrjExECJkyqS-Qd4,32122
+includecpp-3.7.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.7.23.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.7.23.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.7.23.dist-info/RECORD,,