IncludeCPP 3.7.26__tar.gz → 3.8.1__tar.gz

{includecpp-3.7.26 → includecpp-3.8.1}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.26
+Version: 3.8.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -853,3 +853,55 @@ cssl.run('''
     printl(@version);
 ''')
 ```
+
+## Return CSSL Classes to Python
+
+Use `python::pythonize()` to convert CSSL class instances into Python-usable objects:
+
+```python
+from includecpp import CSSL
+
+cssl = CSSL.CsslLang()
+
+# Create and return a CSSL class as a Python object
+greeter = cssl.run('''
+    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;
+        }
+    }
+
+    instance = new Greeter("World");
+    pyclass = python::pythonize(instance);
+    parameter.return(pyclass);
+''')
+
+# Now use it like a normal Python object!
+print(greeter.name)           # "World"
+print(greeter.sayHello())     # "Hello, World!"
+greeter.setName("Python")
+print(greeter.getName())      # "Python"
+print(greeter.name)           # "Python"
+```
+
+### Aliases
+
+- `python::pythonize(instance)` - Main function
+- `python::wrap(instance)` - Alias
+- `python::export(instance)` - Alias
+
+All three do the same thing: wrap a CSSL class instance for Python use.

{includecpp-3.7.26 → includecpp-3.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.26
+Version: 3.8.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -853,3 +853,55 @@ cssl.run('''
     printl(@version);
 ''')
 ```
+
+## Return CSSL Classes to Python
+
+Use `python::pythonize()` to convert CSSL class instances into Python-usable objects:
+
+```python
+from includecpp import CSSL
+
+cssl = CSSL.CsslLang()
+
+# Create and return a CSSL class as a Python object
+greeter = cssl.run('''
+    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;
+        }
+    }
+
+    instance = new Greeter("World");
+    pyclass = python::pythonize(instance);
+    parameter.return(pyclass);
+''')
+
+# Now use it like a normal Python object!
+print(greeter.name)           # "World"
+print(greeter.sayHello())     # "Hello, World!"
+greeter.setName("Python")
+print(greeter.getName())      # "Python"
+print(greeter.name)           # "Python"
+```
+
+### Aliases
+
+- `python::pythonize(instance)` - Main function
+- `python::wrap(instance)` - Alias
+- `python::export(instance)` - Alias
+
+All three do the same thing: wrap a CSSL class instance for Python use.

{includecpp-3.7.26 → includecpp-3.8.1}/README.md

@@ -818,4 +818,56 @@ cssl.run('''
     @log("Application started");
     printl(@version);
 ''')
-```
+```
+
+## Return CSSL Classes to Python
+
+Use `python::pythonize()` to convert CSSL class instances into Python-usable objects:
+
+```python
+from includecpp import CSSL
+
+cssl = CSSL.CsslLang()
+
+# Create and return a CSSL class as a Python object
+greeter = cssl.run('''
+    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;
+        }
+    }
+
+    instance = new Greeter("World");
+    pyclass = python::pythonize(instance);
+    parameter.return(pyclass);
+''')
+
+# Now use it like a normal Python object!
+print(greeter.name)           # "World"
+print(greeter.sayHello())     # "Hello, World!"
+greeter.setName("Python")
+print(greeter.getName())      # "Python"
+print(greeter.name)           # "Python"
+```
+
+### Aliases
+
+- `python::pythonize(instance)` - Main function
+- `python::wrap(instance)` - Alias
+- `python::export(instance)` - Alias
+
+All three do the same thing: wrap a CSSL class instance for Python use.

{includecpp-3.7.26 → includecpp-3.8.1}/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.26"
+__version__ = "3.8.1"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-3.7.26 → includecpp-3.8.1}/includecpp/cli/commands.py

@@ -7457,11 +7457,24 @@ def cssl():
     pass
 
 
+@cssl.command(name='run')
+@click.argument('path', required=False, type=click.Path())
+@click.option('--code', '-c', type=str, help='Execute code directly')
+def cssl_run(path, code):
+    """Run/execute CSSL code or file."""
+    _cssl_execute(path, code)
+
+
 @cssl.command(name='exec')
 @click.argument('path', required=False, type=click.Path())
 @click.option('--code', '-c', type=str, help='Execute code directly')
 def cssl_exec(path, code):
-    """Execute CSSL code or file."""
+    """Execute CSSL code or file (alias for 'run')."""
+    _cssl_execute(path, code)
+
+
+def _cssl_execute(path, code):
+    """Internal: Execute CSSL code or file."""
     from pathlib import Path as PathLib
 
     try:
@@ -7923,16 +7936,18 @@ cli.add_command(cssl)
 
 @cli.command()
 @click.option('--force', '-f', is_flag=True, help='Force overwrite existing files')
+@click.option('--reinstall', '-r', is_flag=True, help='Reinstall extension (removes all versions first)')
 @click.option('--stubs-only', is_flag=True, help='Only update stubs, skip extension files')
-def vscode(force, stubs_only):
+def vscode(force, reinstall, stubs_only):
     """Initialize or update VSCode configuration for IncludeCPP/CSSL.
 
     Installs CSSL extension globally and sets up project stubs.
 
     \b
     Usage:
-      includecpp vscode           # Install/update extension + stubs
-      includecpp vscode --force   # Force reinstall extension
+      includecpp vscode             # Install/update extension + stubs
+      includecpp vscode --force     # Force reinstall extension
+      includecpp vscode --reinstall # Remove ALL versions & reinstall fresh
       includecpp vscode --stubs-only  # Only update stubs
 
     \b
@@ -7999,13 +8014,18 @@ def vscode(force, stubs_only):
                 target_dir = global_ext_dir / f'includecpp.cssl-{current_version}'
 
                 # Check if already installed with same or older version
-                needs_install = force
+                needs_install = force or reinstall
                 existing_version = None
 
                 # Find existing installations
                 for existing in global_ext_dir.glob('includecpp.cssl-*'):
                     existing_version = existing.name.split('-')[-1]
-                    if existing_version != current_version:
+                    if reinstall:
+                        # --reinstall: Remove ALL versions
+                        click.echo(f"  Removing version: {existing_version}")
+                        shutil.rmtree(existing)
+                        needs_install = True
+                    elif existing_version != current_version:
                         # Remove old version
                         click.echo(f"  Removing old version: {existing_version}")
                         shutil.rmtree(existing)

{includecpp-3.7.26 → includecpp-3.8.1}/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
@@ -2445,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

{includecpp-3.7.26 → includecpp-3.8.1}/includecpp/core/cssl/cssl_runtime.py

@@ -2186,7 +2186,12 @@ class CSSLRuntime:
 
         if isinstance(target, ASTNode):
             if target.type == 'identifier':
-                self.scope.set(target.value, value)
+                # Check if we're in a class method and this is a class member
+                # If so, set the member instead of creating a local variable
+                if self._current_instance is not None and self._current_instance.has_member(target.value):
+                    self._current_instance.set_member(target.value, value)
+                else:
+                    self.scope.set(target.value, value)
             elif target.type == 'global_ref':
                 # r@Name = value - store in promoted globals
                 self._promoted_globals[target.value] = value
@@ -2303,6 +2308,9 @@ class CSSLRuntime:
 
         if node.type == 'literal':
             value = node.value
+            # Handle dict-format literals from parser: {'type': 'int', 'value': 0}
+            if isinstance(value, dict) and 'value' in value:
+                value = value['value']
             # String interpolation - replace {var} or <var> with scope values
             if isinstance(value, str):
                 has_fstring = '{' in value and '}' in value
@@ -2323,6 +2331,16 @@ class CSSLRuntime:
         if node.type == 'identifier':
             name = node.value
             value = self.scope.get(name)
+            # Check if it's a class member in current instance context
+            # This allows accessing members without 'this->' inside methods
+            if value is None and self._current_instance is not None:
+                if self._current_instance.has_member(name):
+                    value = self._current_instance.get_member(name)
+                elif self._current_instance.has_method(name):
+                    # Return bound method
+                    method_node = self._current_instance.get_method(name)
+                    instance = self._current_instance
+                    value = lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
             # Fallback to global scope
             if value is None:
                 value = self.global_scope.get(name)

{includecpp-3.7.26 → includecpp-3.8.1}/includecpp/vscode/cssl/package.json

@@ -2,7 +2,7 @@
     "name": "cssl",
     "displayName": "CSSL Language",
     "description": "Professional syntax highlighting, snippets, and language support for CSSL scripts (.cssl, .cssl-pl, .cssl-mod)",
-    "version": "1.3.0",
+    "version": "1.3.1",
     "publisher": "IncludeCPP",
     "icon": "images/cssl.png",
     "engines": {

{includecpp-3.7.26 → includecpp-3.8.1}/includecpp/vscode/cssl/snippets/cssl.snippets.json

@@ -1164,5 +1164,43 @@
             "}"
         ],
         "description": "Function with selectable modifier combinations"
+    },
+    "Python Pythonize": {
+        "prefix": ["python::pythonize", "pythonize"],
+        "body": "python::pythonize(${1:instance})$0",
+        "description": "Convert CSSL class instance to Python-usable object"
+    },
+    "Return Pythonized Class": {
+        "prefix": "returnpython",
+        "body": [
+            "${1:instance} = new ${2:ClassName}(${3:args});",
+            "pyobj = python::pythonize(${1});",
+            "parameter.return(pyobj);"
+        ],
+        "description": "Create class instance and return as Python object"
+    },
+    "Class with Python Export": {
+        "prefix": "pyclass",
+        "body": [
+            "class ${1:ClassName} {",
+            "\t${2:string} ${3:name};",
+            "",
+            "\t${1}(${4:params}) {",
+            "\t\tthis->${3} = ${5:value};",
+            "\t}",
+            "",
+            "\t${6:string} get${3/(.*)/${1:/capitalize}/}() {",
+            "\t\treturn this->${3};",
+            "\t}",
+            "",
+            "\tvoid set${3/(.*)/${1:/capitalize}/}(${2} newValue) {",
+            "\t\tthis->${3} = newValue;",
+            "\t}",
+            "}",
+            "",
+            "${7:obj} = new ${1}(${8:args});",
+            "parameter.return(python::pythonize(${7}));$0"
+        ],
+        "description": "Create a class and export as Python object"
     }
 }

{includecpp-3.7.26 → includecpp-3.8.1}/includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -319,6 +319,14 @@
                 {
                     "name": "support.function.namespace.combo.cssl",
                     "match": "\\bcombo::(filterdb|blocked|like)\\b"
+                },
+                {
+                    "name": "support.function.namespace.python.cssl",
+                    "match": "\\bpython::(pythonize|wrap|export)\\b"
+                },
+                {
+                    "name": "support.function.namespace.filter.cssl",
+                    "match": "\\bfilter::(register|unregister|list|exists)\\b"
                 }
             ]
         },

{includecpp-3.7.26 → includecpp-3.8.1}/pyproject.toml

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