IncludeCPP 3.7.18__tar.gz → 3.7.19__tar.gz

{includecpp-3.7.18 → includecpp-3.7.19}/IncludeCPP.egg-info/PKG-INFO

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

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

{includecpp-3.7.18 → includecpp-3.7.19}/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.18 → includecpp-3.7.19}/includecpp/core/cssl/cssl_builtins.py

@@ -1063,13 +1063,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 +1089,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 +1128,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 +1215,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]:

{includecpp-3.7.18 → includecpp-3.7.19}/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.18 → includecpp-3.7.19}/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):
@@ -1292,6 +1331,12 @@ 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
@@ -1303,6 +1348,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':
@@ -1496,6 +1553,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 +1732,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:

{includecpp-3.7.18 → includecpp-3.7.19}/pyproject.toml

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