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

includecpp/core/cssl/cssl_builtins.py

@@ -205,6 +205,11 @@ class CSSLBuiltins:
         self._functions['isavailable'] = self.builtin_isavailable
         self._functions['instance::exists'] = self.builtin_isavailable  # Alias
 
+        # Python interop functions
+        self._functions['python::pythonize'] = self.builtin_python_pythonize
+        self._functions['python::wrap'] = self.builtin_python_pythonize  # Alias
+        self._functions['python::export'] = self.builtin_python_pythonize  # Alias
+
         # Regex functions
         self._functions['match'] = self.builtin_match
         self._functions['search'] = self.builtin_search
@@ -307,6 +312,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 +442,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',
@@ -1044,6 +1090,13 @@ class CSSLBuiltins:
         Usage: instance::getMethods(@module) or instance::getMethods($obj)
         Returns list of method names.
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            return list(obj._class.methods.keys())
+
+        # Handle Python objects
         import inspect
         methods = []
         for name in dir(obj):
@@ -1056,8 +1109,20 @@ 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
+        if isinstance(obj, CSSLInstance):
+            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
         classes = []
         for name in dir(obj):
@@ -1070,8 +1135,20 @@ 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):
+            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 = []
         for name in dir(obj):
             if not name.startswith('_'):
@@ -1085,12 +1162,31 @@ class CSSLBuiltins:
         Usage: instance::getAll(@module)
         Returns dict with 'methods', 'classes', 'vars' keys.
         """
-        import inspect
+        from .cssl_types import CSSLInstance
+
         result = {
             'methods': [],
             'classes': [],
             'vars': []
         }
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            result['methods'] = list(obj._class.methods.keys())
+            result['classes'] = [obj._class.name]
+
+            # 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
+        import inspect
         for name in dir(obj):
             if not name.startswith('_'):
                 attr = getattr(obj, name, None)
@@ -1106,21 +1202,46 @@ class CSSLBuiltins:
         """Dynamically call a method on an object.
         Usage: instance::call(@module, 'methodName', arg1, arg2)
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            if obj.has_method(method_name):
+                # Need runtime to call the method
+                if self.runtime:
+                    return self.runtime._call_method(obj, obj.get_method(method_name), list(args), kwargs or {})
+            raise RuntimeError(f"Method '{method_name}' not found on CSSL instance")
+
+        # Handle Python objects
         method = getattr(obj, method_name, None)
         if method and callable(method):
             return method(*args, **kwargs)
         raise RuntimeError(f"Method '{method_name}' not found on object")
 
     def builtin_instance_has(self, obj: Any, name: str) -> bool:
-        """Check if object has an attribute.
+        """Check if object has an attribute or method.
         Usage: instance::has(@module, 'methodName')
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            return obj.has_member(name) or obj.has_method(name)
+
+        # Handle Python objects
         return hasattr(obj, name)
 
     def builtin_instance_type(self, obj: Any) -> str:
         """Get the type name of an object.
         Usage: instance::type(@module)
         """
+        from .cssl_types import CSSLInstance
+
+        # Handle CSSL class instances
+        if isinstance(obj, CSSLInstance):
+            return obj._class.name
+
+        # Handle Python objects
         return type(obj).__name__
 
     def builtin_isavailable(self, name_or_obj: Any) -> bool:
@@ -1140,6 +1261,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]:
@@ -1680,7 +1845,7 @@ class CSSLBuiltins:
 
     def builtin_cso_root(self, path: str = "") -> str:
         """
-        Get absolute path relative to CSO root directory
+        Get absolute path relative to project root directory
         Usage: cso_root('/services/myservice.cssl')
         Returns: Full absolute path to the file
         """
@@ -1729,7 +1894,7 @@ class CSSLBuiltins:
             if os.path.exists(cwd_path):
                 filepath = cwd_path
             else:
-                # Fall back to cso_root for CSO service context
+                # Fall back to cso_root for service context
                 filepath = self.builtin_cso_root(filepath)
 
         # Check file exists
@@ -1923,7 +2088,7 @@ class CSSLBuiltins:
                 if os.path.exists(cwd_path):
                     filepath = cwd_path
                 else:
-                    # Fall back to cso_root for CSO service context
+                    # Fall back to cso_root for service context
                     filepath = self.builtin_cso_root(filepath)
 
             # Check file exists
@@ -2203,6 +2368,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.
 
@@ -2253,6 +2450,211 @@ class CSSLBuiltins:
 
         return None
 
+    # ============= Python Interop Functions =============
+
+    def builtin_python_pythonize(self, cssl_instance: Any) -> Any:
+        """Convert a CSSL class instance to a Python-usable object.
+
+        This allows CSSL classes to be returned and used in Python code
+        with proper attribute access and method calls.
+
+        Usage in CSSL:
+            class Greeter {
+                string name;
+
+                Greeter(string n) {
+                    this->name = n;
+                }
+
+                string sayHello() {
+                    return "Hello, " + this->name + "!";
+                }
+
+                void setName(string newName) {
+                    this->name = newName;
+                }
+
+                string getName() {
+                    return this->name;
+                }
+            }
+
+            greeter = new Greeter("World");
+            pyclass = python::pythonize(greeter);
+            parameter.return(pyclass);
+
+        Usage in Python:
+            from includecpp import CSSL
+
+            cssl = CSSL.CsslLang()
+            greeter = cssl.run('''
+                class Greeter { ... }
+                g = new Greeter("World");
+                parameter.return(python::pythonize(g));
+            ''')
+
+            # Now use it like a normal Python object:
+            print(greeter.name)           # "World"
+            print(greeter.sayHello())     # "Hello, World!"
+            greeter.setName("Python")
+            print(greeter.getName())      # "Python"
+
+        Args:
+            cssl_instance: A CSSLInstance object (created via 'new ClassName()')
+
+        Returns:
+            PythonizedCSSLInstance - A Python-friendly wrapper
+        """
+        from .cssl_types import CSSLInstance, CSSLClass
+
+        if cssl_instance is None:
+            return None
+
+        # Already pythonized
+        if isinstance(cssl_instance, PythonizedCSSLInstance):
+            return cssl_instance
+
+        # Must be a CSSLInstance
+        if not isinstance(cssl_instance, CSSLInstance):
+            # If it's a dict, wrap it as a simple object
+            if isinstance(cssl_instance, dict):
+                return PythonizedDict(cssl_instance)
+            # Return as-is for primitives
+            return cssl_instance
+
+        return PythonizedCSSLInstance(cssl_instance, self.runtime)
+
+
+class PythonizedCSSLInstance:
+    """Python wrapper for CSSL class instances.
+
+    Provides Pythonic attribute access and method calling for CSSL objects.
+    """
+
+    def __init__(self, instance: Any, runtime: Any = None):
+        # Use object.__setattr__ to avoid triggering our custom __setattr__
+        object.__setattr__(self, '_cssl_instance', instance)
+        object.__setattr__(self, '_cssl_runtime', runtime)
+        object.__setattr__(self, '_cssl_class_name', instance._class.name if hasattr(instance, '_class') else 'Unknown')
+
+    def __getattr__(self, name: str) -> Any:
+        """Get member or method from CSSL instance."""
+        if name.startswith('_'):
+            raise AttributeError(f"'{self._cssl_class_name}' has no attribute '{name}'")
+
+        instance = object.__getattribute__(self, '_cssl_instance')
+        runtime = object.__getattribute__(self, '_cssl_runtime')
+
+        # Check for member variable first
+        if instance.has_member(name):
+            value = instance.get_member(name)
+            # Recursively pythonize nested CSSL instances
+            from .cssl_types import CSSLInstance
+            if isinstance(value, CSSLInstance):
+                return PythonizedCSSLInstance(value, runtime)
+            return value
+
+        # Check for method
+        method = instance.get_method(name)
+        if method is not None:
+            # Return a callable wrapper for the method
+            return PythonizedMethod(instance, name, method, runtime)
+
+        raise AttributeError(f"'{self._cssl_class_name}' has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Set member value on CSSL instance."""
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+            return
+
+        instance = object.__getattribute__(self, '_cssl_instance')
+        instance.set_member(name, value)
+
+    def __repr__(self) -> str:
+        class_name = object.__getattribute__(self, '_cssl_class_name')
+        instance = object.__getattribute__(self, '_cssl_instance')
+        members = list(instance._members.keys()) if hasattr(instance, '_members') else []
+        return f"<PythonizedCSSL '{class_name}' members={members}>"
+
+    def __dir__(self) -> list:
+        """List available attributes."""
+        instance = object.__getattribute__(self, '_cssl_instance')
+        members = list(instance._members.keys()) if hasattr(instance, '_members') else []
+        methods = list(instance._class.methods.keys()) if hasattr(instance._class, 'methods') else []
+        return members + methods
+
+    def _to_dict(self) -> dict:
+        """Convert to Python dictionary."""
+        instance = object.__getattribute__(self, '_cssl_instance')
+        result = {}
+        for name, value in instance._members.items():
+            from .cssl_types import CSSLInstance
+            if isinstance(value, CSSLInstance):
+                result[name] = PythonizedCSSLInstance(value, None)._to_dict()
+            else:
+                result[name] = value
+        return result
+
+
+class PythonizedMethod:
+    """Wrapper that makes CSSL methods callable from Python."""
+
+    def __init__(self, instance: Any, method_name: str, method_ast: Any, runtime: Any):
+        self._instance = instance
+        self._method_name = method_name
+        self._method_ast = method_ast
+        self._runtime = runtime
+
+    def __call__(self, *args, **kwargs) -> Any:
+        """Call the CSSL method with arguments."""
+        if self._runtime is None:
+            raise RuntimeError(f"Cannot call method '{self._method_name}' - no runtime available")
+
+        # Execute the method through the runtime
+        # Pass the method AST node, not the method name
+        result = self._runtime._call_method(self._instance, self._method_ast, list(args), kwargs)
+
+        # Pythonize the result if it's a CSSL instance
+        from .cssl_types import CSSLInstance
+        if isinstance(result, CSSLInstance):
+            return PythonizedCSSLInstance(result, self._runtime)
+
+        return result
+
+    def __repr__(self) -> str:
+        return f"<method '{self._method_name}' of '{self._instance._class.name}'>"
+
+
+class PythonizedDict:
+    """Simple wrapper for dict objects with attribute access."""
+
+    def __init__(self, data: dict):
+        object.__setattr__(self, '_data', data)
+
+    def __getattr__(self, name: str) -> Any:
+        data = object.__getattribute__(self, '_data')
+        if name in data:
+            value = data[name]
+            if isinstance(value, dict):
+                return PythonizedDict(value)
+            return value
+        raise AttributeError(f"No attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+            return
+        data = object.__getattribute__(self, '_data')
+        data[name] = value
+
+    def __repr__(self) -> str:
+        data = object.__getattribute__(self, '_data')
+        return f"<PythonizedDict {data}>"
+
+    def _to_dict(self) -> dict:
+        return object.__getattribute__(self, '_data')
+
 
 # Module-level convenience functions
 _default_builtins: Optional[CSSLBuiltins] = None