IncludeCPP 3.7.25__py3-none-any.whl → 3.8.8__py3-none-any.whl

includecpp/core/cssl/cssl_builtins.py

@@ -205,6 +205,13 @@ 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
+        self._functions['python::csslize'] = self.builtin_python_csslize
+        self._functions['python::import'] = self.builtin_python_csslize  # Alias
+
         # Regex functions
         self._functions['match'] = self.builtin_match
         self._functions['search'] = self.builtin_search
@@ -2445,6 +2452,342 @@ 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)
+
+    def builtin_python_csslize(self, python_obj: Any) -> Any:
+        """Convert a Python object (class instance or function) to a CSSL-compatible wrapper.
+
+        Syntax:
+            cssl_obj <== python::csslize($python_instance);
+            cssl_func <== python::csslize($python_function);
+
+        Example:
+            # In Python:
+            class MyPythonClass:
+                def __init__(self, name):
+                    self.name = name
+                def greet(self):
+                    return f"Hello, {self.name}!"
+
+            cssl = CSSL.CsslLang()
+            cssl.set_variable('MyPython', MyPythonClass("World"))
+            result = cssl.run('''
+                py_obj <== python::csslize($MyPython);
+                printl(py_obj.greet());  // "Hello, World!"
+            ''')
+
+        For class inheritance:
+            py_class <== python::csslize($MyPythonClass);
+            class MyExtended : extends py_class {
+                void newMethod() { ... }
+            }
+
+        Args:
+            python_obj: A Python object (class instance, function, or class)
+
+        Returns:
+            CSSLizedPythonObject - A CSSL-compatible wrapper
+        """
+        if python_obj is None:
+            return None
+
+        # Already csslized
+        if isinstance(python_obj, CSSLizedPythonObject):
+            return python_obj
+
+        # Wrap the Python object
+        return CSSLizedPythonObject(python_obj, self.runtime)
+
+
+class CSSLizedPythonObject:
+    """CSSL wrapper for Python objects (classes, instances, functions).
+
+    Allows Python objects to be used within CSSL code, including as base classes.
+    """
+
+    def __init__(self, python_obj: Any, runtime: Any = None):
+        self._python_obj = python_obj
+        self._runtime = runtime
+        self._is_class = isinstance(python_obj, type)
+        self._is_callable = callable(python_obj) and not self._is_class
+
+    def __repr__(self):
+        if self._is_class:
+            return f"<CSSLizedPythonClass: {self._python_obj.__name__}>"
+        elif self._is_callable:
+            return f"<CSSLizedPythonFunction: {getattr(self._python_obj, '__name__', 'anonymous')}>"
+        else:
+            return f"<CSSLizedPythonInstance: {type(self._python_obj).__name__}>"
+
+    def __call__(self, *args, **kwargs):
+        """Call the wrapped object (for functions or class instantiation)."""
+        return self._python_obj(*args, **kwargs)
+
+    def __getattr__(self, name: str) -> Any:
+        """Get attribute from wrapped Python object."""
+        if name.startswith('_'):
+            raise AttributeError(f"Cannot access private attribute '{name}'")
+
+        obj = object.__getattribute__(self, '_python_obj')
+
+        if hasattr(obj, name):
+            attr = getattr(obj, name)
+            # If it's a method, wrap it for CSSL calling
+            if callable(attr):
+                return CSSLizedPythonMethod(attr, self._runtime)
+            return attr
+
+        raise AttributeError(f"Python object has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any):
+        """Set attribute on wrapped Python object."""
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._python_obj, name, value)
+
+    def has_member(self, name: str) -> bool:
+        """Check if the Python object has a member."""
+        return hasattr(self._python_obj, name)
+
+    def get_member(self, name: str) -> Any:
+        """Get a member from the Python object."""
+        return getattr(self._python_obj, name, None)
+
+    def set_member(self, name: str, value: Any):
+        """Set a member on the Python object."""
+        setattr(self._python_obj, name, value)
+
+    def get_method(self, name: str):
+        """Get a method from the Python object."""
+        if hasattr(self._python_obj, name):
+            method = getattr(self._python_obj, name)
+            if callable(method):
+                return CSSLizedPythonMethod(method, self._runtime)
+        return None
+
+    def get_python_obj(self):
+        """Get the underlying Python object (for inheritance)."""
+        return self._python_obj
+
+
+class CSSLizedPythonMethod:
+    """Wrapper for Python methods to be called from CSSL."""
+
+    def __init__(self, method: Any, runtime: Any = None):
+        self._method = method
+        self._runtime = runtime
+
+    def __call__(self, *args, **kwargs):
+        """Call the Python method."""
+        return self._method(*args, **kwargs)
+
+    def __repr__(self):
+        return f"<CSSLizedPythonMethod: {getattr(self._method, '__name__', 'anonymous')}>"
+
+
+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