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

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.25"
+__version__ = "3.8.0"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

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/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/core/cssl/cssl_parser.py

@@ -716,7 +716,7 @@ class CSSLParser:
     def _is_type_keyword(self, value: str) -> bool:
         """Check if a keyword is a type declaration"""
         return value in ('int', 'string', 'float', 'bool', 'void', 'json', 'array', 'vector', 'stack',
-                        'list', 'dictionary', 'dict', 'instance', 'map',
+                        'list', 'dictionary', 'dict', 'instance', 'map', 'openquote', 'parameter',
                         'dynamic', 'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo', 'structure')
 
     def _looks_like_function_declaration(self) -> bool:
@@ -727,14 +727,17 @@ class CSSLParser:
         - undefined int funcName(...)
         - vector<string> funcName(...)
         - undefined void funcName(...)
+        - private super virtual meta FuncName(...)  <- modifiers without return type
         """
         saved_pos = self.pos
+        has_modifiers = False
 
         # Skip modifiers (undefined, open, meta, super, closed, private, virtual)
         while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
             self._advance()
+            has_modifiers = True
 
-        # Check for type keyword
+        # Check for type keyword (optional if modifiers present)
         if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
             self._advance()
 
@@ -756,6 +759,14 @@ class CSSLParser:
                 self.pos = saved_pos
                 return is_func
 
+        # If we have modifiers and the next token is an identifier followed by (
+        # This handles: private super virtual meta FuncName()
+        elif has_modifiers and self._check(TokenType.IDENTIFIER):
+            self._advance()
+            is_func = self._check(TokenType.PAREN_START)
+            self.pos = saved_pos
+            return is_func
+
         self.pos = saved_pos
         return False
 

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
@@ -2323,6 +2328,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/vscode/cssl/extension.js

@@ -53,23 +53,23 @@ function activate(context) {
         // Run the CSSL file using includecpp cssl run
         const args = ['-m', 'includecpp', 'cssl', 'run', filePath];
 
-        const process = spawn(pythonPath, args, {
+        const childProcess = spawn(pythonPath, args, {
             cwd: path.dirname(filePath),
             env: { ...process.env }
         });
 
         let hasError = false;
 
-        process.stdout.on('data', (data) => {
+        childProcess.stdout.on('data', (data) => {
             outputChannel.append(data.toString());
         });
 
-        process.stderr.on('data', (data) => {
+        childProcess.stderr.on('data', (data) => {
             hasError = true;
             outputChannel.append(data.toString());
         });
 
-        process.on('close', (code) => {
+        childProcess.on('close', (code) => {
             outputChannel.appendLine('');
             outputChannel.appendLine('─'.repeat(50));
             if (code === 0) {
@@ -79,7 +79,7 @@ function activate(context) {
             }
         });
 
-        process.on('error', (err) => {
+        childProcess.on('error', (err) => {
             outputChannel.appendLine(`[CSSL] Error: ${err.message}`);
             vscode.window.showErrorMessage(`Failed to run CSSL: ${err.message}. Make sure IncludeCPP is installed (pip install includecpp).`);
         });

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/vscode/cssl/snippets/cssl.snippets.json

@@ -1076,5 +1076,131 @@
             "}"
         ],
         "description": "Open parameter function"
+    },
+    "Undefined Function": {
+        "prefix": ["undefined", "undef"],
+        "body": [
+            "undefined ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Function with undefined modifier - suppresses all errors during execution"
+    },
+    "Private Function": {
+        "prefix": "private",
+        "body": [
+            "private ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Private function - disables all external injections"
+    },
+    "Closed Function": {
+        "prefix": "closed",
+        "body": [
+            "closed ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Closed function - protects from external injection modifications"
+    },
+    "Virtual Function": {
+        "prefix": "virtual",
+        "body": [
+            "virtual ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Virtual function - can be overridden in child classes"
+    },
+    "Meta Function": {
+        "prefix": "meta",
+        "body": [
+            "meta ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Meta function - metaprogramming function for code generation"
+    },
+    "Super Function": {
+        "prefix": "super",
+        "body": [
+            "super ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Super function - enhanced privileges for system-level operations"
+    },
+    "SQLBased Function": {
+        "prefix": "sqlbased",
+        "body": [
+            "sqlbased ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "SQL-based function - optimized for database operations"
+    },
+    "API Function with Modifiers": {
+        "prefix": ["apifunc", "globalapi"],
+        "body": [
+            "private super virtual meta ${1:GlobalApi}() {",
+            "\tinstance<\"${2:apiName}\"> api;",
+            "\tclass ${3:Api} {",
+            "\t\tdefine ${4:getMethod}() {",
+            "\t\t\t$0",
+            "\t\t}",
+            "\t}",
+            "\t%api +<== new ${3}();",
+            "\treturn %api;",
+            "}"
+        ],
+        "description": "Global API function with full modifiers and instance pattern"
+    },
+    "Combined Modifiers Function": {
+        "prefix": "modfunc",
+        "body": [
+            "${1|undefined,private,closed,virtual,meta,super,sqlbased|} ${2|undefined,private,closed,virtual,meta,super,sqlbased,void,int,string|} ${3:FuncName}(${4:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "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/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.25.dist-info → includecpp-3.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.25
+Version: 3.8.0
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -839,7 +839,7 @@ print(math_mod.multiply(4, 5))  # 20
 cssl = CSSL.CsslLang()
 
 # Register code as payload
-cssl.code("helpers", '''
+cssl.script(<name>, "helpers", '''
     global version = "1.0.0";
     void log(string msg) {
         printl("[LOG] " + msg);
@@ -847,230 +847,61 @@ cssl.code("helpers", '''
 ''')
 
 # Use in CSSL
-cssl.exec('''
-    payload("helpers");
+cssl.run('''
+    payload("<name>"); // use module you declared in cssl.script(<name>, ...)
     @log("Application started");
     printl(@version);
 ''')
 ```
 
-# Changelog
-
-## v3.4.20
-- **Documentation:**
-  - Added complete CSSL language documentation
-  - Live object sharing with `$name` syntax
-  - Data types, control flow, functions, injection system
-  - String methods, modules, and inline payloads
-
-## v3.4.19
-- **Critical Bug Fixes:**
-  - Fixed generator raw string literal in parser.cpp (regex pattern with `)"` prematurely terminated)
-  - Fixed shared object property writes inside loops not persisting to Python
-  - Added member_access handling in flow operations for shared objects
-
-## v3.4.18
-- **Bug Fix:**
-  - Attempted fix for shared object loop writes (partially fixed)
-
-## v3.4.17
-- **New Feature: Live Object Sharing**
-  - `cssl.share(instance, name)` - Share Python objects with CSSL
-  - `$name` syntax for accessing shared objects
-  - Live bidirectional updates - changes in CSSL reflect in Python
-  - `delete("name")` builtin for removing shared objects
-  - Shared object metadata stored in `%APPDATA%/IncludeCPP/shared_objects/`
-
-## v3.4.16
-- **CSSL Bug Fixes:**
-  - Fixed `startsWith()` and `endsWith()` parser errors
-
-## v3.4.15
-- **CSSL Enhancements:**
-  - Added `elif` keyword support
-  - Added `range(start, end, step)` with step parameter
-  - Added `begin()` and `end()` methods to all collection types
-  - Added `cssl.code(name, code)` for inline payload registration
-
-## v3.4.2
-- **New Feature: `exec` Command**
-  - Interactive REPL for quick code testing without creating files
-  - `includecpp exec py` - Python REPL with IncludeCPP support
-  - `includecpp exec cpp` - C++ REPL with auto-compilation
-  - Auto-import modules: `includecpp exec py mymodule`
-  - Auto-import from plugins: `includecpp exec py plugins/math.cp`
-  - Import all modules: `includecpp exec py --all`
-  - Enter code line by line, press ENTER on empty line to execute
-
-## v3.4.1
-- **Bug Fixes:**
-  - fix command: Fixed false positives for unused variables (sum, memory_) using word-boundary matching
-  - CPPY: C++ reserved words (double, int, void, etc.) now properly escaped as Python identifiers
-  - CPPY: C++ STL functions (accumulate, find, sort, reverse) properly converted to Python equivalents
-  - CPPY: Member variables with trailing underscore (memory_) now get self. prefix
-  - CPPY: Private class members now detected for self. prefix conversion
-  - Plugin: Auto-detect header files from #include directives in source files
-
-## v3.4.0
-- **CodeMaker Major Update:**
-  - New Source node type with 8 connection ports for code generation
-  - Smart code generation: Source nodes generate Python/Plugin files with all connected nodes included
-  - Right-click on Source node: "Create Python" creates .py in project root
-  - Right-click on Source node: "Create Plugin" creates .cp, .h, .cpp in plugins/ and include/
-  - Code options hidden after file generation (prevents duplicates)
-  - Enhanced description display with background rect in node body
-  - Arrow key navigation to pan the canvas
-  - New toolbar buttons: Align H, Align V, Auto-Arrange
-  - Quick-add buttons: +Source, +Class, +Function
-  - Properties Panel on the right side for editing selected nodes
-  - Auto-arrange algorithm for grid layout
-  - Align horizontal/vertical for selected nodes
-- **Bug Fixes:**
-  - Changelog encoding fixes for Windows console
-  - CPPY C++ keyword escaping (double, int, etc.)
-  - CPPY C++ to Python syntax conversion improvements
-  - CPPY self. prefix for member variables
-  - Plugin auto-header detection from #include
-
-## v3.3.21
-- **Encoding Fixes:**
-  - Replaced Unicode arrow characters with ASCII in changelog (Windows console compatibility)
-
-## v3.3.20
-- **Bug Fixes:**
-  - Fixed `QPoint.toPoint()` AttributeError in rubber band selection
-  - Added UTF-8 encoding to all file read/write operations for cross-platform compatibility
-  - Fixed bare `except:` clauses to proper `except Exception:` in settings_ui.py
-
-## v3.3.19
-- **PyQt6 Import Fix:**
-  - Fixed silent import failure that caused "PyQt6 not installed" error even when installed
-  - Moved `QUndoStack`, `QUndoCommand`, `QShortcut` from QtWidgets to QtGui (correct location in PyQt6)
-
-## v3.3.18
-- **CodeMaker Visual Editor (Experimental):**
-  - Complete rewrite of `project` command with professional-grade UI
-  - 24 node types across 5 categories (Code Structures, Functions, Data, Organization, Flow)
-  - Undo/redo system with full command history
-  - Multi-selection with rubber band and Ctrl+Click
-  - Copy/paste/duplicate with Ctrl+C/V/D shortcuts
-  - Node grouping with Ctrl+G
-  - Code generation for C++ (header/source) and Python
-  - Search and filter nodes by name and type
-  - Export to PNG/SVG with transparency support
-  - Categorized right-click context menus
-  - Toolbar with common actions
-  - Cross-platform font detection (Windows/macOS/Linux)
-  - DPI-aware scaling for high-resolution displays
-- **Experimental Feature Gating:**
-  - `project` command now requires "Enable Experimental Features" in settings
-  - Consistent gating with `ai` and `cppy` commands
-
-## v3.3.16-3.3.17
-- **QPen Bug Fixes:**
-  - Fixed 3 instances of `setPen(Qt.PenStyle.NoPen)` to `setPen(QPen(Qt.PenStyle.NoPen))`
-  - Proper QPen construction for PyQt6 compatibility
-
-## v3.3.15
-- **CPPY Converter Major Fixes:**
-  - Functions returning container now get `std::vector<T>` return type (e.g., shuffle_list)
-  - `max(items)` / `min(items)` now correctly uses `std::max_element` / `std::min_element`
-  - Template element parameters (`value`, `item`) now use `const T&` instead of `double`
-  - Explicit template instantiations now include correct return types and all parameters
-  - Python docstrings now become C++ comments instead of dangling string literals
-- **Unicode Fallback System:**
-  - AI progress indicators use ASCII fallbacks on Windows terminals
-  - Fixed encoding errors in changelog display
-
-## v3.3.14
-- **Experimental Features System:**
-  - AI and CPPY commands now hidden by default
-  - Enable via Settings UI: "Enable Experimental Features" checkbox
-  - Warning about potential bugs documented in README
-- **Settings UI Improvements:**
-  - Added scrollable content area to prevent layout squashing
-  - New "Experimental" section with orange header
-  - Better spacing and styling for all elements
-  - Preserved existing config values on save
-
-## v3.3.13
-- **Template Support for Generic Functions:**
-  - Generic container parameters now generate proper C++ templates
-  - `template<typename T> T getChoice(const std::vector<T>& choices)` instead of invalid `std::vector<auto>`
-  - Automatic explicit template instantiations for int, double, std::string
-- **AI Conversion - No pybind11:**
-  - AI no longer generates pybind11 code - IncludeCPP handles bindings automatically
-  - Clean C++ output in `namespace includecpp`
-  - User runs `includecpp plugin` separately to generate bindings
-- **AI Context - Dynamic README:**
-  - AI now loads README.md dynamically for accurate IncludeCPP documentation
-  - Better understanding of IncludeCPP workflow and patterns
-
-## v3.3.12
-- **Smart Type Inference:**
-  - Parameter types now inferred from common naming patterns (start/end -> int, name/path -> string, etc.)
-  - Variable type tracking throughout conversion for accurate string detection
-  - Loop variable types inferred from iterables (enumerate, for loops)
-- **String Conversion Fix:**
-  - No more `std::to_string()` on already-string variables in f-strings
-  - `_is_string_expr()` method for comprehensive string type detection
-  - String variables detected by name, type tracking, and method calls
-- **AI Conversion Improvements:**
-  - Explicit file extension enforcement (.cpp NOT .cp, .h NOT .hpp)
-  - Better --no-h flag handling with clear AI instructions
-  - AI can request clarification on unconvertible modules (tkinter, pygame, etc.)
-  - User prompted for input when AI needs guidance
-
-## v3.3.11
-- **CPPY Converter Improvements:**
-  - Added `_safe_arg()` and `_safe_get()` for robust bounds checking on all args
-  - Added comprehensive try-except handling in `_convert_expr()` with warnings
-  - Improved type inference with empty container handling and exception safety
-  - Complete string escaping: `\0`, `\f`, `\b`, `\a`, `\v` now properly escaped
-- **New Python Constructs:**
-  - Dict comprehensions: `{k: v for k, v in items}` now converts to C++
-  - Set comprehensions: `{x for x in items}` now converts to C++
-  - Generator expressions: `(x for x in items)` now converts to vector
-  - Tuple unpacking: `a, b = func()` now uses C++17 structured bindings
-- **AI Conversion Flags:**
-  - New `--think` flag for less context mode
-  - New `--think3` flag for maximum context mode
-  - New `--websearch` flag for web search in AI conversion
-  - Default: `--think2` mode (unchanged behavior)
-
-## v3.3.10
-- **CPPY Converter seeded RNG fixes:**
-  - Fixed `rng = random.Random(seed)` then `rng.randint()` - now properly tracks seeded RNG variables
-  - Fixed `random.choices(...)[0]` subscript - returns single element directly without `[0]`
-  - Seeded RNG methods (randint, uniform, choice, random) now use the tracked variable with proper C++ distributions
-
-## v3.3.9
-- **CPPY Converter fixes:**
-  - Added f-string (JoinedStr) support - f"text {expr}" now converts to string concatenation
-  - Fixed `random.Random(seed).method()` chained calls - now generates proper inline lambda with seeded RNG
-  - Fixed `random.choices(items, weights=weights)` keyword argument handling
-  - Improved string type detection in f-string expressions
-
-## v3.3.8
-- **Major rulebased converter improvements:**
-  - Added Python `random` module support (randint, uniform, choice, sample, shuffle, gauss, etc.)
-  - Added `os` module support (getcwd, path.join, path.exists, listdir, mkdir, etc.)
-  - Added `time` module support (sleep, time, perf_counter, monotonic)
-  - Added `sys` module support (exit, platform)
-  - Added `math` module support (sqrt, pow, sin, cos, log, etc.)
-  - Added `re` (regex) module support (match, search, sub, findall)
-  - Added `threading` module support (Thread, Lock, Semaphore, etc.)
-  - Added `collections` module support (deque, defaultdict, Counter)
-  - Added `pathlib.Path` support
-- **Unconvertible code detection:**
-  - Automatically detects GUI frameworks (tkinter, PyQt, PySide, pygame) and other unconvertible modules
-  - Shows red warning with line numbers when unconvertible code is found
-  - New `--force` flag to convert anyway (with `/* UNCONVERTIBLE */` comments)
-  - Supports 30+ modules in detection (numpy, pandas, flask, django, etc.)
-- Fixed duplicate file output in `cppy convert --ai`
-- Plugin command now skips inline and underscore-prefixed functions
-
-
----
-
-MIT License | v3.4.20 | [GitHub](https://github.com/liliassg/IncludeCPP)
+## 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.25.dist-info → includecpp-3.8.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-includecpp/__init__.py,sha256=YgP_G9kl_90bbm_zr9NJq-rDfpM76tC8vfJGNIHBYxY,1673
+includecpp/__init__.py,sha256=cheZCblYfeG2PZg9V8rAeFxzczvL3Ii7cjvuC6lE6Jw,1672
 includecpp/__init__.pyi,sha256=uSDYlbqd2TinmrdepmE_zvN25jd3Co2cgyPzXgDpopM,7193
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 includecpp/cli/__init__.py,sha256=Yda-4a5QJb_tKu35YQNfc5lu-LewTsM5abqNNkzS47M,113
-includecpp/cli/commands.py,sha256=HDoRuPEPTzxZQcR4rF45GrRVtcw3zDj6cGiwLCZB44Y,349597
+includecpp/cli/commands.py,sha256=R1wZeka7AMUVd61TSTUZ2utjCdorFY3wO_Ahs749iyc,350475
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
 includecpp/core/ai_integration.py,sha256=PW6yFDqdXjfchpfKTKg59AOLhLry9kqJEGf_65BztrY,87603
@@ -21,12 +21,12 @@ includecpp/core/project_ui.py,sha256=la2EQZKmUkJGuJxnbs09hH1ZhBh9bfndo6okzZsk2dQ
 includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCEQ,11798
 includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=47sUPO-FMq_8_CrJBZFoFBgSO3gSi5zoB1Xp7oeifho,40773
 includecpp/core/cssl/__init__.py,sha256=scDXRBNK2L6A8qmlpNyaqQj6BFcSfPInBlucdeNfMF0,1975
-includecpp/core/cssl/cssl_builtins.py,sha256=r-FX4WQeKxerkepqodIiwhtL_kxxa4PJym_WyWIwA_s,92290
+includecpp/core/cssl/cssl_builtins.py,sha256=B_ggaV4zE1kejphXmo0-_XKFyxU4BWv_g0j_KzHpLJI,100225
 includecpp/core/cssl/cssl_builtins.pyi,sha256=3ai2V4LyhzPBhAKjRRf0rLVu_bg9ECmTfTkdFKM64iA,127430
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
-includecpp/core/cssl/cssl_parser.py,sha256=fphjjN2MRURMkqi0lFEf6l61xC9IPImlYVjlqonZZHc,117139
-includecpp/core/cssl/cssl_runtime.py,sha256=iZgNcKDoTeV50-IsXcsrpuTyDPxEHWyQz5uR3s5UVHg,154613
+includecpp/core/cssl/cssl_parser.py,sha256=WxfqNhsryt5IR7KdDgbHrrYlXS-xBXTsr3YAiGBJZIc,117711
+includecpp/core/cssl/cssl_runtime.py,sha256=LeBZJeiK_XjhJ1QoU1duLxgr6MNb8EenluCRBUtNIyE,155680
 includecpp/core/cssl/cssl_syntax.py,sha256=bgo3NFehoPTQa5dqwNd_CstkVGVCNYAXbGYUcu5BEN0,16982
 includecpp/core/cssl/cssl_types.py,sha256=gVjtfxk0Uzfj-H7_LD79oqspFMYDf79ZrRrlZk8eAEs,50647
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
@@ -37,16 +37,16 @@ includecpp/generator/type_resolver.h,sha256=ZsaxQqcCcKJJApYn7KOp2dLlQ1VFVG_oZDja
 includecpp/templates/cpp.proj.template,sha256=Iy-L8I4Cl3tIgBMx1Qp5h6gURvkqOAqyodVHuDJ0Luw,359
 includecpp/vscode/__init__.py,sha256=yLKw-_7MTX1Rx3jLk5JjharJQfFXbwtZVE7YqHpM7yg,39
 includecpp/vscode/cssl/__init__.py,sha256=rQJAx5X05v-mAwqX1Qb-rbZO219iR73MziFNRUCNUIo,31
-includecpp/vscode/cssl/extension.js,sha256=YLFDuKQVdGi15l_vUadD9nlu8mcjzUm_rKj4-oxV-ak,4302
+includecpp/vscode/cssl/extension.js,sha256=FZaKfOpzo2jXtubVCZmnhDZd4eUVHltm5VW_fgNnSkE,4327
 includecpp/vscode/cssl/language-configuration.json,sha256=61Q00cKI9may5L8YpxMmvfo6PAc-abdJqApfR85DWuw,904
-includecpp/vscode/cssl/package.json,sha256=Zu2QoTE0OVCCDUHp1hc7kN2NBbFs60bX-LLGMpXz25M,4853
+includecpp/vscode/cssl/package.json,sha256=kTV4gTigAQ93FIoidjlZW3znKT2_KOXDo2e8evNFTNs,4853
 includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86MsvUGlSZw,510
 includecpp/vscode/cssl/images/cssl_pl.png,sha256=z4WMk7g6YCTbUUbSFk343BO6yi_OmNEVYkRenWGydwM,799
-includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=l4SCEPR3CsPxA8HIVLKYY__I979TfKzYWtH1KYIsboo,33062
-includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=XKRLBOHlCqDDnGPvmNHDQPsIMR1UD9PBaJIlgZOiPqM,21173
-includecpp-3.7.25.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.7.25.dist-info/METADATA,sha256=7e3lYqfMjuU6hs9mv5Ol5l7Zpjtr5I_QXp5Mmxh2ftQ,32122
-includecpp-3.7.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.7.25.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.7.25.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.7.25.dist-info/RECORD,,
+includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=uV3nHJyQ5f7Pr3FzfbQT2VZOEY3AlGs4wrmqe884jm4,37372
+includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=ArCRc_G54kiKGh6WEd4CbmR-SX1X9BOcp3Y0hwZcw44,21543
+includecpp-3.8.0.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.8.0.dist-info/METADATA,sha256=gnvN0QtGJ_QWGfkyXFKR1kwE4z-8sRz10k3Z3lIMBvs,22510
+includecpp-3.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.8.0.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.8.0.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.8.0.dist-info/RECORD,,