IncludeCPP 3.7.17__tar.gz → 3.7.23__tar.gz

{includecpp-3.7.17 → includecpp-3.7.23}/IncludeCPP.egg-info/PKG-INFO

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

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

{includecpp-3.7.17 → includecpp-3.7.23}/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-3.7.17 → includecpp-3.7.23}/includecpp/core/cssl/__init__.py

@@ -16,7 +16,10 @@ from .cssl_parser import (
     CSSLSyntaxError, CSSLLexer, CSSLParser, ASTNode,
     KEYWORDS, TYPE_GENERICS, TYPE_PARAM_FUNCTIONS, INJECTION_HELPERS
 )
-from .cssl_runtime import CSSLRuntime, CSSLRuntimeError, CSSLServiceRunner, run_cssl, run_cssl_file
+from .cssl_runtime import (
+    CSSLRuntime, CSSLRuntimeError, CSSLServiceRunner, run_cssl, run_cssl_file,
+    register_filter, unregister_filter, get_custom_filters
+)
 from .cssl_types import (
     DataStruct, Shuffled, Iterator, Combo, DataSpace, OpenQuote,
     OpenFind, Parameter, Stack, Vector, Array,
@@ -33,6 +36,8 @@ __all__ = [
     # Runtime
     'CSSLRuntime', 'CSSLRuntimeError', 'CSSLServiceRunner',
     'run_cssl', 'run_cssl_file',
+    # Filter Registration
+    'register_filter', 'unregister_filter', 'get_custom_filters',
     # Data Types
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
     'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array',

{includecpp-3.7.17 → includecpp-3.7.23}/includecpp/core/cssl/cssl_builtins.py

@@ -307,6 +307,10 @@ class CSSLBuiltins:
         self._functions['dataspace'] = self.builtin_dataspace
         self._functions['openquote'] = self.builtin_openquote
         self._functions['OpenFind'] = self.builtin_openfind
+        self._functions['vector'] = self.builtin_vector
+        self._functions['array'] = self.builtin_array
+        self._functions['stack'] = self.builtin_stack
+        self._functions['map'] = self.builtin_map
 
         # Print aliases for CSSL
         self._functions['printl'] = self.builtin_println  # CSSL uses printl for println
@@ -433,13 +437,50 @@ class CSSLBuiltins:
     # ============= Type Checking =============
 
     def builtin_typeof(self, value: Any) -> str:
-        """Get type name"""
+        """Get type name - returns CSSL-specific type names for CSSL types"""
         if value is None:
             return 'null'
+
+        # Check CSSL-specific types first
+        from .cssl_types import (Vector, Array, Stack, DataStruct,
+                                  List as CSSLList, Dictionary, Map,
+                                  Shuffled, Iterator, Combo, DataSpace,
+                                  OpenQuote, Parameter, CSSLInstance)
+
+        if isinstance(value, Vector):
+            return 'vector'
+        elif isinstance(value, Array):
+            return 'array'
+        elif isinstance(value, Stack):
+            return 'stack'
+        elif isinstance(value, DataStruct):
+            return 'datastruct'
+        elif isinstance(value, CSSLList):
+            return 'list'
+        elif isinstance(value, Dictionary):
+            return 'dictionary'
+        elif isinstance(value, Map):
+            return 'map'
+        elif isinstance(value, Shuffled):
+            return 'shuffled'
+        elif isinstance(value, Iterator):
+            return 'iterator'
+        elif isinstance(value, Combo):
+            return 'combo'
+        elif isinstance(value, DataSpace):
+            return 'dataspace'
+        elif isinstance(value, OpenQuote):
+            return 'openquote'
+        elif isinstance(value, Parameter):
+            return 'parameter'
+        elif isinstance(value, CSSLInstance):
+            return value._class.name
+
+        # Python types as fallback
         type_map = {
             int: 'int',
             float: 'float',
-            str: 'str',
+            str: 'string',
             bool: 'bool',
             list: 'list',
             dict: 'dict',
@@ -1063,13 +1104,18 @@ class CSSLBuiltins:
     def builtin_instance_getClasses(self, obj: Any) -> list:
         """Get all classes from an object/module.
         Usage: instance::getClasses(@module)
-        Returns list of class names.
+        Returns list of class names (including merged classes).
         """
         from .cssl_types import CSSLInstance
 
-        # Handle CSSL class instances - they don't contain nested classes
+        # Handle CSSL class instances
         if isinstance(obj, CSSLInstance):
-            return [obj._class.name]  # Return the class name itself
+            classes = [obj._class.name]  # Primary class
+            # Check for merged class instances in members
+            for name, member in obj._members.items():
+                if isinstance(member, CSSLInstance):
+                    classes.append(member._class.name)
+            return classes
 
         # Handle Python objects
         import inspect
@@ -1084,13 +1130,18 @@ class CSSLBuiltins:
     def builtin_instance_getVars(self, obj: Any) -> list:
         """Get all variables/attributes (non-callable) from an object.
         Usage: instance::getVars(@module)
-        Returns list of variable names.
+        Returns list of variable names (excludes merged class instances).
         """
         from .cssl_types import CSSLInstance
 
         # Handle CSSL class instances
         if isinstance(obj, CSSLInstance):
-            return list(obj._members.keys())
+            vars_list = []
+            for name, member in obj._members.items():
+                # Exclude merged class instances
+                if not isinstance(member, CSSLInstance):
+                    vars_list.append(name)
+            return vars_list
 
         # Handle Python objects
         vars_list = []
@@ -1118,7 +1169,15 @@ class CSSLBuiltins:
         if isinstance(obj, CSSLInstance):
             result['methods'] = list(obj._class.methods.keys())
             result['classes'] = [obj._class.name]
-            result['vars'] = list(obj._members.keys())
+
+            # Separate regular vars from merged class instances
+            for name, member in obj._members.items():
+                if isinstance(member, CSSLInstance):
+                    # Merged class - add to classes list
+                    result['classes'].append(member._class.name)
+                else:
+                    # Regular variable
+                    result['vars'].append(name)
             return result
 
         # Handle Python objects
@@ -1197,6 +1256,50 @@ class CSSLBuiltins:
         # Otherwise, check if the object is not None (for $name or instance<"name">)
         return name_or_obj is not None
 
+    # ============= Filter Registration Functions =============
+
+    def builtin_filter_register(self, filter_type: str, helper: str, callback: Any) -> bool:
+        """Register a custom filter.
+        Usage: filter::register("mytype", "where", myCallback)
+
+        The callback receives (source, filter_value, runtime) and returns filtered result.
+        Use "*" as helper for catch-all.
+
+        Example:
+            define myFilter(source, value, runtime) {
+                return source + value;
+            }
+            filter::register("custom", "add", myFilter);
+
+            result <==[custom::add=10] 5;  // result = 15
+        """
+        from .cssl_runtime import register_filter
+        register_filter(filter_type, helper, callback)
+        return True
+
+    def builtin_filter_unregister(self, filter_type: str, helper: str) -> bool:
+        """Unregister a custom filter.
+        Usage: filter::unregister("mytype", "where")
+        """
+        from .cssl_runtime import unregister_filter
+        return unregister_filter(filter_type, helper)
+
+    def builtin_filter_list(self) -> list:
+        """List all registered custom filters.
+        Usage: filter::list()
+        Returns list of filter keys like ["mytype::where", "custom::*"]
+        """
+        from .cssl_runtime import get_custom_filters
+        return list(get_custom_filters().keys())
+
+    def builtin_filter_exists(self, filter_type: str, helper: str) -> bool:
+        """Check if a custom filter exists.
+        Usage: filter::exists("mytype", "where")
+        """
+        from .cssl_runtime import get_custom_filters
+        key = f"{filter_type}::{helper}"
+        return key in get_custom_filters()
+
     # ============= Regex Functions =============
 
     def builtin_match(self, pattern: str, string: str) -> Optional[dict]:
@@ -2260,6 +2363,38 @@ class CSSLBuiltins:
         from .cssl_types import OpenQuote
         return OpenQuote(db_ref)
 
+    def builtin_vector(self, element_type: str = 'dynamic') -> Any:
+        """Create a vector container.
+
+        Usage: vector<int> myVector; or vector('int')
+        """
+        from .cssl_types import Vector
+        return Vector(element_type)
+
+    def builtin_array(self, element_type: str = 'dynamic') -> Any:
+        """Create an array container.
+
+        Usage: array<string> myArray; or array('string')
+        """
+        from .cssl_types import Array
+        return Array(element_type)
+
+    def builtin_stack(self, element_type: str = 'dynamic') -> Any:
+        """Create a stack container.
+
+        Usage: stack<int> myStack; or stack('int')
+        """
+        from .cssl_types import Stack
+        return Stack(element_type)
+
+    def builtin_map(self, key_type: str = 'dynamic', value_type: str = 'dynamic') -> Any:
+        """Create a map container.
+
+        Usage: map<string, int> myMap; or map('string', 'int')
+        """
+        from .cssl_types import Map
+        return Map(key_type, value_type)
+
     def builtin_openfind(self, combo_or_type: Any, index: int = 0, params: list = None) -> Any:
         """Find open parameter by type or combo space.
 

{includecpp-3.7.17 → includecpp-3.7.23}/includecpp/core/cssl/cssl_builtins.pyi

@@ -2082,6 +2082,85 @@ def isavailable(name_or_obj: Any) -> bool:
     """
     ...
 
+# =============================================================================
+# FILTER REGISTRATION FUNCTIONS (filter:: namespace)
+# =============================================================================
+# Custom filters allow extending the BruteInjection system with user-defined
+# filter types. Register filters that can then be used in injection syntax:
+#   result <==[mytype::myhelper="value"] source;
+
+def filter_register(filter_type: str, helper: str, callback: Callable[[Any, Any, Any], Any]) -> bool:
+    """Register a custom filter.
+
+    Usage in CSSL: filter::register("mytype", "helper", callback)
+
+    Args:
+        filter_type: The filter type name (e.g., "custom", "mytype")
+        helper: The helper name (e.g., "where", "add") or "*" for catch-all
+        callback: Function(source, filter_value, runtime) -> filtered_result
+
+    Example:
+        // Define a custom filter callback
+        define addFilter(source, value, runtime) {
+            return source + value;
+        }
+
+        // Register the filter
+        filter::register("math", "add", addFilter);
+
+        // Use the filter
+        result <==[math::add=10] 5;  // result = 15
+
+        // Register a catch-all filter
+        define catchAll(source, value, runtime) {
+            printl("Filter called with: " + str(value));
+            return source;
+        }
+        filter::register("debug", "*", catchAll);
+    """
+    ...
+
+def filter_unregister(filter_type: str, helper: str) -> bool:
+    """Unregister a custom filter.
+
+    Usage in CSSL: filter::unregister("mytype", "helper")
+
+    Returns:
+        True if filter was found and removed, False otherwise
+
+    Example:
+        filter::unregister("math", "add");
+    """
+    ...
+
+def filter_list() -> List[str]:
+    """List all registered custom filters.
+
+    Usage in CSSL: filter::list()
+
+    Returns:
+        List of filter keys like ["math::add", "debug::*"]
+
+    Example:
+        stack<string> filters = filter::list();
+        foreach (f in filters) {
+            printl("Registered filter: " + f);
+        }
+    """
+    ...
+
+def filter_exists(filter_type: str, helper: str) -> bool:
+    """Check if a custom filter exists.
+
+    Usage in CSSL: filter::exists("mytype", "helper")
+
+    Example:
+        if (filter::exists("math", "add")) {
+            result <==[math::add=5] 10;
+        }
+    """
+    ...
+
 # =============================================================================
 # REGEX FUNCTIONS
 # =============================================================================

{includecpp-3.7.17 → includecpp-3.7.23}/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 == '>':
@@ -848,7 +852,7 @@ class CSSLParser:
             if self._match_keyword('open'):
                 param_info['open'] = True
 
-            # Handle type annotations
+            # Handle type annotations (builtin types like int, string, etc.)
             if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
                 param_info['type'] = self._advance().value
 
@@ -872,6 +876,39 @@ class CSSLParser:
                         self._advance()
                     param_info['generic'] = ''.join(generic_parts)
 
+            # Handle custom class types (identifier followed by another identifier = type + name)
+            elif self._check(TokenType.IDENTIFIER):
+                # Look ahead: if next token is also an identifier, current is the type
+                saved_pos = self.pos
+                potential_type = self._advance().value
+
+                # Check for generic type parameter <T> on custom type
+                if self._check(TokenType.COMPARE_LT):
+                    self._advance()
+                    generic_parts = []
+                    depth = 1
+                    while depth > 0 and not self._is_at_end():
+                        if self._check(TokenType.COMPARE_LT):
+                            depth += 1
+                            generic_parts.append('<')
+                        elif self._check(TokenType.COMPARE_GT):
+                            depth -= 1
+                            if depth > 0:
+                                generic_parts.append('>')
+                        elif self._check(TokenType.COMMA):
+                            generic_parts.append(',')
+                        else:
+                            generic_parts.append(self._current().value)
+                        self._advance()
+                    param_info['generic'] = ''.join(generic_parts)
+
+                # If followed by identifier, this is "Type name" pattern
+                if self._check(TokenType.IDENTIFIER):
+                    param_info['type'] = potential_type
+                else:
+                    # Not a type, restore position - this is just a param name
+                    self.pos = saved_pos
+
             # Handle reference operator &
             if self._match(TokenType.AMPERSAND):
                 param_info['ref'] = True
@@ -1882,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()
@@ -2118,6 +2165,11 @@ class CSSLParser:
             elif self._match(TokenType.COMPARE_GE):
                 right = self._parse_term()
                 left = ASTNode('binary', value={'op': '>=', 'left': left, 'right': right})
+            elif self._check(TokenType.KEYWORD) and self._peek().value == 'in':
+                # 'in' operator for containment: item in list
+                self._advance()  # consume 'in'
+                right = self._parse_term()
+                left = ASTNode('binary', value={'op': 'in', 'left': left, 'right': right})
             else:
                 break
 
@@ -2504,6 +2556,20 @@ class CSSLParser:
 
                 self._expect(TokenType.BLOCK_END)  # consume }
 
+            # Check for array-style initialization: vector<int>[1, 2, 3], array<string>["a", "b"]
+            elif self._check(TokenType.BRACKET_START):
+                self._advance()  # consume [
+                init_values = []
+
+                while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
+                    init_values.append(self._parse_expression())
+
+                    # Optional comma
+                    if self._check(TokenType.COMMA):
+                        self._advance()
+
+                self._expect(TokenType.BRACKET_END)  # consume ]
+
             return ASTNode('type_instantiation', value={
                 'type': name,
                 'element_type': element_type,