IncludeCPP 3.7.25__py3-none-any.whl → 3.8.8__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.8"
 __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_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.7.6 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
+> Version 3.8.6 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
 
 ---
 
@@ -1696,6 +1696,317 @@ string result = b.add("Hello ").add("World!").build();
 printl(result);  // prints: "Hello World!"
 ```
 
+### Class Inheritance (extends)
+
+CSSL supports class inheritance using the `: extends` syntax:
+
+```cssl
+// Base class
+class Animal {
+    string name;
+
+    void Animal(string n) {
+        this->name = n;
+    }
+
+    void speak() {
+        printl("Some sound");
+    }
+}
+
+// Derived class - inherits all members and methods from Animal
+class Dog : extends Animal {
+    void Dog(string n) {
+        this->name = n;
+    }
+
+    // Override parent method
+    void speak() {
+        printl("Woof! I'm " + this->name);
+    }
+
+    // New method only in Dog
+    void fetch() {
+        printl(this->name + " fetches the ball!");
+    }
+}
+
+Dog d = new Dog("Buddy");
+d.speak();    // "Woof! I'm Buddy"
+d.fetch();    // "Buddy fetches the ball!"
+```
+
+### Extending Python Objects
+
+You can extend Python classes/objects directly:
+
+```cssl
+// Extend a Python object using $
+class ExtendedGame : extends $GameEngine {
+    void newFeature() {
+        printl("New CSSL feature!");
+    }
+
+    // Override a Python method
+    void showUsername() {
+        printl("Custom username display: " + this->username);
+    }
+}
+```
+
+In Python:
+```python
+class GameEngine:
+    def __init__(self):
+        self.username = "Player1"
+    def showUsername(self):
+        print(f"Username: {self.username}")
+
+cssl = CSSL.CsslLang()
+cssl.share('GameEngine', GameEngine())
+cssl.run('''
+    class MyGame : extends $GameEngine {
+        void customMethod() {
+            printl("Extended from Python!");
+        }
+    }
+''')
+```
+
+### Class Overwrites
+
+Use `: overwrites` to replace methods in an existing class/object:
+
+```cssl
+// Overwrite methods in a Python object
+class MyOverrides : extends $GameEngine : overwrites $GameEngine {
+    // This method will REPLACE the original showUsername() in $GameEngine
+    void showUsername() {
+        printl("OVERWRITTEN: " + this->username);
+    }
+}
+```
+
+When you use `: overwrites TargetClass`, all methods defined in your class will replace the corresponding methods in the target. This works with:
+- Other CSSL classes
+- Python objects via `$ObjectName`
+- Shared objects
+
+### python::csslize() - Import Python Objects
+
+Convert Python objects to CSSL-compatible wrappers:
+
+```cssl
+// Import a Python object
+py_obj <== python::csslize($MyPythonInstance);
+
+// Now use it like a CSSL object
+py_obj.someMethod();
+printl(py_obj.someProperty);
+
+// Or use it as a base class
+class Extended : extends py_obj {
+    void newMethod() { ... }
+}
+```
+
+In Python:
+```python
+class MyPythonClass:
+    def __init__(self, name):
+        self.name = name
+    def greet(self):
+        return f"Hello, {self.name}!"
+
+cssl = CSSL.CsslLang()
+cssl.share('MyPython', MyPythonClass("World"))
+result = cssl.run('''
+    py_obj <== python::csslize($MyPython);
+    printl(py_obj.greet());  // "Hello, World!"
+''')
+```
+
+### Function Extends & Overwrites
+
+Functions can also extend or overwrite other functions:
+
+```cssl
+// Base function
+define baseFunction() {
+    string greeting = "Hello";
+    int count = 42;
+    printl(greeting);
+}
+
+// Extend: inherit local variables from baseFunction
+define extendedFunc : extends baseFunction() {
+    // 'greeting' and 'count' are available here!
+    printl(greeting + " World! Count: " + count);
+}
+
+// Overwrite: replace the original function
+define myReplacement : overwrites baseFunction() {
+    printl("This replaces baseFunction entirely!");
+}
+
+// After defining myReplacement, calling baseFunction()
+// will now execute myReplacement instead
+baseFunction();  // prints: "This replaces baseFunction entirely!"
+```
+
+Overwriting Python functions:
+```cssl
+// Replace a shared Python function
+define myVersion : overwrites $pythonFunc() {
+    printl("CSSL implementation replaces Python!");
+}
+```
+
+### Non-Null Declarations
+
+Use `*` prefix to declare non-nullable items:
+
+```cssl
+// Non-null variable - can never be None
+vector<dynamic> *myList;  // Always initialized, never null
+
+// Non-null function - must never return None
+define *alwaysReturns() {
+    return "Always a value";  // Error if returns null
+}
+
+// Non-null class - all methods return non-null
+class *MyClass {
+    string getValue() {
+        return "Value";  // All methods must return non-null
+    }
+}
+
+// Non-null open parameter - filters out None values
+define process(open *Params) {
+    // Params will never contain None values
+    foreach item in Params {
+        printl(item);  // Guaranteed non-null
+    }
+}
+```
+
+### Class Constructors with `constr` Keyword
+
+The `constr` keyword defines explicit constructors inside classes. Multiple constructors can be defined and will be executed in order.
+
+```cssl
+// Class with constructor parameters in declaration
+class Vehicle (string brand, int year) {
+    string make;
+    int modelYear;
+
+    // Constructor using constr keyword
+    constr Initialize() {
+        // brand and year are available from class parameters
+        this->make = brand;
+        this->modelYear = year;
+    }
+
+    // Additional constructor - executed after Initialize
+    constr SetupDefaults() {
+        printl("Vehicle created: " + this->make);
+    }
+}
+
+Vehicle v = new Vehicle("Toyota", 2024);
+```
+
+### Constructor Inheritance with `super()`
+
+Use `super()` to call parent class constructors and methods:
+
+```cssl
+class Animal {
+    string name;
+
+    void Animal(string n) {
+        this->name = n;
+    }
+
+    void speak() {
+        printl("Generic sound");
+    }
+}
+
+class Dog : extends Animal {
+    string breed;
+
+    constr DogInit(string n, string b) {
+        super(n);  // Call parent constructor with name
+        this->breed = b;
+    }
+
+    void speak() {
+        super::speak();  // Call parent's speak method
+        printl("Woof! I'm " + this->name);
+    }
+}
+
+Dog d = new Dog("Buddy", "Labrador");
+d.speak();
+// Output:
+// Generic sound
+// Woof! I'm Buddy
+```
+
+### Constructor Extends with Arguments
+
+Pass arguments to parent constructors in class declaration:
+
+```cssl
+class Parent {
+    int value;
+
+    void Parent(int v) {
+        this->value = v;
+    }
+}
+
+// Pass arguments to parent constructor using extends (arg1, arg2)
+class Child : extends Parent ("defaultValue") {
+    constr ChildInit() {
+        // Parent constructor already called with "defaultValue"
+        printl("Child value: " + this->value);
+    }
+}
+```
+
+### Method-Level Extends & Overwrites
+
+Functions and methods can extend or overwrite specific methods in parent classes using `::` syntax:
+
+```cssl
+class Base {
+    constr Init() {
+        printl("Base init");
+    }
+
+    void process() {
+        printl("Base processing");
+    }
+}
+
+class Derived : extends Base {
+    // Extend specific parent constructor
+    constr DerivedInit() :: extends Base::Init {
+        // Base::Init local vars are available here
+        printl("Derived init");
+    }
+
+    // Or define a method that extends parent method
+    define customProcess :: extends Base::process() {
+        // Has access to Base::process local variables
+        printl("Extended processing");
+    }
+}
+```
+
 ---
 
 ## Map Container