IncludeCPP 3.7.22__tar.gz → 3.7.24__tar.gz

{includecpp-3.7.22 → includecpp-3.7.24}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.22
+Version: 3.7.24
 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.22 → includecpp-3.7.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.22
+Version: 3.7.24
 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.22 → includecpp-3.7.24}/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.22"
+__version__ = "3.7.24"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-3.7.22 → includecpp-3.7.24}/includecpp/core/cssl/cssl_parser.py

@@ -951,6 +951,27 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
+    def _looks_like_namespace_call(self) -> bool:
+        """Check if current position looks like a namespace function call.
+
+        Pattern: keyword::identifier(...) like json::write(), string::cut()
+        This allows type keywords to be used as namespace prefixes for function calls.
+        """
+        if not self._check(TokenType.KEYWORD):
+            return False
+
+        # Save position
+        saved_pos = self.pos
+
+        self._advance()  # Skip keyword
+
+        # Must be followed by ::
+        result = self._check(TokenType.DOUBLE_COLON)
+
+        # Restore position
+        self.pos = saved_pos
+        return result
+
     def _looks_like_typed_variable(self) -> bool:
         """Check if current position looks like a typed variable declaration:
         type_name varName; or type_name<T> varName; or type_name varName = value;
@@ -1452,7 +1473,8 @@ class CSSLParser:
         elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
               self._check(TokenType.CAPTURED_REF) or self._check(TokenType.SHARED_REF) or
               self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF) or
-              (self._check(TokenType.KEYWORD) and self._current().value in ('this', 'new'))):
+              (self._check(TokenType.KEYWORD) and self._current().value in ('this', 'new')) or
+              self._looks_like_namespace_call()):
             return self._parse_expression_statement()
         else:
             self._advance()
@@ -1919,32 +1941,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-3.7.22 → includecpp-3.7.24}/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():
@@ -2004,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.22 → includecpp-3.7.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IncludeCPP"
-version = "3.7.22"
+version = "3.7.24"
 description = "Professional C++ Python bindings with type-generic templates, pystubs and native threading"
 readme = "README.md"
 requires-python = ">=3.9"