IncludeCPP 3.6.0__tar.gz → 3.6.1__tar.gz

{includecpp-3.6.0 → includecpp-3.6.1}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.6.0
+Version: 3.6.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.6.0 → includecpp-3.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.6.0
+Version: 3.6.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.6.0 → includecpp-3.6.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.6.0"
+__version__ = "3.6.1"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-3.6.0 → includecpp-3.6.1}/includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.6.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
+> Version 3.6.1 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
 
 ---
 
@@ -17,17 +17,18 @@
 9. [String Methods](#string-methods)
 10. [File I/O](#file-io)
 11. [JSON Functions](#json-functions)
-12. [Live Object Sharing](#live-object-sharing)
-13. [CodeInfusion](#codeinfusion)
-14. [Value Capture](#value-capture)
-15. [BruteInjection](#bruteinjection)
-16. [Filter Syntax](#filter-syntax)
-17. [Module System](#module-system)
-18. [Parameter Bridge](#parameter-bridge)
-19. [Structures](#structures)
-20. [Error Handling](#error-handling)
-21. [CLI Commands](#cli-commands)
-22. [Examples](#examples)
+12. [Instance Management](#instance-management)
+13. [Live Object Sharing](#live-object-sharing)
+14. [CodeInfusion](#codeinfusion)
+15. [Value Capture](#value-capture)
+16. [BruteInjection](#bruteinjection)
+17. [Filter Syntax](#filter-syntax)
+18. [Module System](#module-system)
+19. [Parameter Bridge](#parameter-bridge)
+20. [Structures](#structures)
+21. [Error Handling](#error-handling)
+22. [CLI Commands](#cli-commands)
+23. [Examples](#examples)
 
 ---
 
@@ -1000,6 +1001,81 @@ json merged = json::merge(obj1, obj2, obj3);
 
 ---
 
+## Instance Management
+
+CSSL provides `instance<"name">` syntax and `instance::` namespace for working with shared instances.
+
+### Instance Declaration
+
+```cssl
+// Get/create shared instance by name
+instance<"MyApp"> app;
+
+// With initialization
+instance<"tk"> tk = include("tkinter.cssl-mod");
+
+// Register object as shared instance
+myModule ==> $AppModule
+// Or using instance syntax:
+myModule ==> instance<"AppModule">
+```
+
+### Instance Introspection
+
+```cssl
+@tk = include("tk.cssl-mod");
+
+// Get all methods from module
+stack<string> methods = instance::getMethods(@tk);
+foreach (m in methods) {
+    printl("Method: " + m);
+}
+
+// Get all classes
+stack<string> classes = instance::getClasses(@tk);
+
+// Get all variables
+stack<string> vars = instance::getVars(@tk);
+
+// Get everything categorized
+json all = instance::getAll(@tk);
+printl(all.methods);   // ["method1", "method2", ...]
+printl(all.classes);   // ["Class1", "Class2", ...]
+printl(all.vars);      // ["var1", "var2", ...]
+```
+
+### Dynamic Method Calls
+
+```cssl
+// Call method dynamically by name
+result = instance::call(@module, "methodName", arg1, arg2);
+
+// Check if method/attribute exists
+if (instance::has(@module, "initialize")) {
+    instance::call(@module, "initialize");
+}
+
+// Get type name
+string typeName = instance::type(@module);
+printl(typeName);  // "module"
+```
+
+### All Instance Functions
+
+| Function | Description |
+|----------|-------------|
+| `instance<"name"> var` | Declare instance variable |
+| `obj ==> instance<"name">` | Register as shared instance |
+| `instance::getMethods(obj)` | Get all method names |
+| `instance::getClasses(obj)` | Get all class names |
+| `instance::getVars(obj)` | Get all variable names |
+| `instance::getAll(obj)` | Get categorized dict |
+| `instance::call(obj, 'name', ...)` | Call method dynamically |
+| `instance::has(obj, 'name')` | Check if attribute exists |
+| `instance::type(obj)` | Get type name |
+
+---
+
 ## Live Object Sharing
 
 Share Python objects with CSSL. Changes in CSSL reflect back to Python.
@@ -1810,4 +1886,4 @@ print(result)  # ["Missing colon after def"]
 
 ---
 
-*CSSL v3.6.0 - Developed as part of IncludeCPP*
+*CSSL v3.6.1 - Developed as part of IncludeCPP*

{includecpp-3.6.0 → includecpp-3.6.1}/includecpp/core/cssl/cssl_builtins.py

@@ -194,6 +194,15 @@ class CSSLBuiltins:
         self._functions['json::has'] = self.builtin_json_has
         self._functions['json::merge'] = self.builtin_json_merge
 
+        # Instance introspection functions (instance::getMethods, etc.)
+        self._functions['instance::getMethods'] = self.builtin_instance_getMethods
+        self._functions['instance::getClasses'] = self.builtin_instance_getClasses
+        self._functions['instance::getVars'] = self.builtin_instance_getVars
+        self._functions['instance::getAll'] = self.builtin_instance_getAll
+        self._functions['instance::call'] = self.builtin_instance_call
+        self._functions['instance::has'] = self.builtin_instance_has
+        self._functions['instance::type'] = self.builtin_instance_type
+
         # Regex functions
         self._functions['match'] = self.builtin_match
         self._functions['search'] = self.builtin_search
@@ -1026,6 +1035,92 @@ class CSSLBuiltins:
                 result = deep_merge(result, d)
         return result
 
+    # ============= Instance Introspection Functions =============
+
+    def builtin_instance_getMethods(self, obj: Any) -> list:
+        """Get all methods from an object/module.
+        Usage: instance::getMethods(@module) or instance::getMethods($obj)
+        Returns list of method names.
+        """
+        import inspect
+        methods = []
+        for name in dir(obj):
+            if not name.startswith('_'):
+                attr = getattr(obj, name, None)
+                if callable(attr):
+                    methods.append(name)
+        return methods
+
+    def builtin_instance_getClasses(self, obj: Any) -> list:
+        """Get all classes from an object/module.
+        Usage: instance::getClasses(@module)
+        Returns list of class names.
+        """
+        import inspect
+        classes = []
+        for name in dir(obj):
+            if not name.startswith('_'):
+                attr = getattr(obj, name, None)
+                if inspect.isclass(attr):
+                    classes.append(name)
+        return classes
+
+    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.
+        """
+        vars_list = []
+        for name in dir(obj):
+            if not name.startswith('_'):
+                attr = getattr(obj, name, None)
+                if not callable(attr):
+                    vars_list.append(name)
+        return vars_list
+
+    def builtin_instance_getAll(self, obj: Any) -> dict:
+        """Get all attributes from an object, categorized.
+        Usage: instance::getAll(@module)
+        Returns dict with 'methods', 'classes', 'vars' keys.
+        """
+        import inspect
+        result = {
+            'methods': [],
+            'classes': [],
+            'vars': []
+        }
+        for name in dir(obj):
+            if not name.startswith('_'):
+                attr = getattr(obj, name, None)
+                if inspect.isclass(attr):
+                    result['classes'].append(name)
+                elif callable(attr):
+                    result['methods'].append(name)
+                else:
+                    result['vars'].append(name)
+        return result
+
+    def builtin_instance_call(self, obj: Any, method_name: str, *args, **kwargs) -> Any:
+        """Dynamically call a method on an object.
+        Usage: instance::call(@module, 'methodName', arg1, arg2)
+        """
+        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.
+        Usage: instance::has(@module, 'methodName')
+        """
+        return hasattr(obj, name)
+
+    def builtin_instance_type(self, obj: Any) -> str:
+        """Get the type name of an object.
+        Usage: instance::type(@module)
+        """
+        return type(obj).__name__
+
     # ============= Regex Functions =============
 
     def builtin_match(self, pattern: str, string: str) -> Optional[dict]:

{includecpp-3.6.0 → includecpp-3.6.1}/includecpp/core/cssl/cssl_parser.py

@@ -898,7 +898,7 @@ class CSSLParser:
         type_keywords = {'int', 'string', 'float', 'bool', 'dynamic', 'void',
                         'stack', 'vector', 'datastruct', 'dataspace', 'shuffled',
                         'iterator', 'combo', 'array', 'openquote', 'json',
-                        'list', 'dictionary', 'dict'}
+                        'list', 'dictionary', 'dict', 'instance'}
         if type_name not in type_keywords:
             return False
 
@@ -927,11 +927,13 @@ class CSSLParser:
         # Get type name
         type_name = self._advance().value  # Consume type keyword
 
-        # Check for generic type <T>
+        # Check for generic type <T> or instance<"name">
         element_type = None
         if self._match(TokenType.COMPARE_LT):
-            # Get element type
-            if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+            # For instance<"name">, element_type can be a string literal
+            if type_name == 'instance' and self._check(TokenType.STRING):
+                element_type = self._advance().value
+            elif self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
                 element_type = self._advance().value
             self._expect(TokenType.COMPARE_GT)
 
@@ -947,6 +949,14 @@ class CSSLParser:
 
         self._match(TokenType.SEMICOLON)
 
+        # For instance<"name">, create a special node type
+        if type_name == 'instance':
+            return ASTNode('instance_declaration', value={
+                'instance_name': element_type,
+                'name': var_name,
+                'value': value
+            })
+
         return ASTNode('typed_declaration', value={
             'type': type_name,
             'element_type': element_type,
@@ -1992,14 +2002,10 @@ class CSSLParser:
             # Continue to check for calls, indexing, member access on module refs
             while True:
                 if self._match(TokenType.PAREN_START):
-                    # Function call on module ref: @Module.method()
-                    args = []
-                    while not self._check(TokenType.PAREN_END) and not self._is_at_end():
-                        args.append(self._parse_expression())
-                        if not self._check(TokenType.PAREN_END):
-                            self._expect(TokenType.COMMA)
+                    # Function call on module ref: @Module.method() - with kwargs support
+                    args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
-                    node = ASTNode('call', value={'callee': node, 'args': args})
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
                 elif self._match(TokenType.DOT):
                     # Member access: @Module.property
                     member = self._advance().value
@@ -2017,31 +2023,23 @@ class CSSLParser:
             # s@<name> self-reference to global struct
             token = self._advance()
             node = ASTNode('self_ref', value=token.value, line=token.line, column=token.column)
-            # Check for function call: s@Backend.Loop.Start()
+            # Check for function call: s@Backend.Loop.Start() - with kwargs support
             if self._match(TokenType.PAREN_START):
-                args = []
-                while not self._check(TokenType.PAREN_END):
-                    args.append(self._parse_expression())
-                    if not self._check(TokenType.PAREN_END):
-                        self._expect(TokenType.COMMA)
+                args, kwargs = self._parse_call_arguments()
                 self._expect(TokenType.PAREN_END)
-                node = ASTNode('call', value={'callee': node, 'args': args})
+                node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
             return node
 
         if self._check(TokenType.GLOBAL_REF):
             # r@<name> global variable reference/declaration
             token = self._advance()
             node = ASTNode('global_ref', value=token.value, line=token.line, column=token.column)
-            # Check for member access, calls, indexing
+            # Check for member access, calls, indexing - with kwargs support
             while True:
                 if self._match(TokenType.PAREN_START):
-                    args = []
-                    while not self._check(TokenType.PAREN_END):
-                        args.append(self._parse_expression())
-                        if not self._check(TokenType.PAREN_END):
-                            self._expect(TokenType.COMMA)
+                    args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
-                    node = ASTNode('call', value={'callee': node, 'args': args})
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
                 elif self._match(TokenType.DOT):
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
@@ -2057,16 +2055,12 @@ class CSSLParser:
             # $<name> shared object reference
             token = self._advance()
             node = ASTNode('shared_ref', value=token.value, line=token.line, column=token.column)
-            # Check for member access, calls, indexing
+            # Check for member access, calls, indexing - with kwargs support
             while True:
                 if self._match(TokenType.PAREN_START):
-                    args = []
-                    while not self._check(TokenType.PAREN_END):
-                        args.append(self._parse_expression())
-                        if not self._check(TokenType.PAREN_END):
-                            self._expect(TokenType.COMMA)
+                    args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
-                    node = ASTNode('call', value={'callee': node, 'args': args})
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
                 elif self._match(TokenType.DOT):
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
@@ -2082,16 +2076,12 @@ class CSSLParser:
             # %<name> captured reference (captures value at infusion registration time)
             token = self._advance()
             node = ASTNode('captured_ref', value=token.value, line=token.line, column=token.column)
-            # Check for member access, calls, indexing
+            # Check for member access, calls, indexing - with kwargs support
             while True:
                 if self._match(TokenType.PAREN_START):
-                    args = []
-                    while not self._check(TokenType.PAREN_END):
-                        args.append(self._parse_expression())
-                        if not self._check(TokenType.PAREN_END):
-                            self._expect(TokenType.COMMA)
+                    args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
-                    node = ASTNode('call', value={'callee': node, 'args': args})
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
                 elif self._match(TokenType.DOT):
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
@@ -2160,14 +2150,10 @@ class CSSLParser:
                 member = self._advance().value
                 node = ASTNode('member_access', value={'object': node, 'member': member})
             elif self._match(TokenType.PAREN_START):
-                # Function call
-                args = []
-                while not self._check(TokenType.PAREN_END):
-                    args.append(self._parse_expression())
-                    if not self._check(TokenType.PAREN_END):
-                        self._expect(TokenType.COMMA)
+                # Function call - use _parse_call_arguments for kwargs support
+                args, kwargs = self._parse_call_arguments()
                 self._expect(TokenType.PAREN_END)
-                node = ASTNode('call', value={'callee': node, 'args': args})
+                node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
             elif self._match(TokenType.BRACKET_START):
                 # Index access
                 index = self._parse_expression()
@@ -2220,6 +2206,19 @@ class CSSLParser:
                 namespace_member = self._advance().value
                 name = f"{name}::{namespace_member}"
 
+        # Check for instance<"name"> syntax - gets/creates shared instance
+        if name == 'instance' and self._check(TokenType.COMPARE_LT):
+            self._advance()  # consume <
+            # Expect string literal for instance name
+            if self._check(TokenType.STRING):
+                instance_name = self._advance().value
+            elif self._check(TokenType.IDENTIFIER):
+                instance_name = self._advance().value
+            else:
+                raise CSSLParserError("Expected instance name (string or identifier)", self._current_line())
+            self._expect(TokenType.COMPARE_GT)  # consume >
+            return ASTNode('instance_ref', value=instance_name)
+
         # Check for type generic instantiation: stack<string>, vector<int>, etc.
         # This creates a new instance of the type with the specified element type
         if name in TYPE_GENERICS and self._check(TokenType.COMPARE_LT):

{includecpp-3.6.0 → includecpp-3.6.1}/includecpp/core/cssl/cssl_runtime.py

@@ -394,6 +394,9 @@ class CSSLRuntime:
             elif child.type == 'typed_declaration':
                 # Handle typed variable declaration: type<T> varName = value;
                 result = self._exec_typed_declaration(child)
+            elif child.type == 'instance_declaration':
+                # Handle instance declaration: instance<"name"> varName;
+                result = self._exec_instance_declaration(child)
             elif child.type in ('assignment', 'expression', 'inject', 'receive', 'flow',
                                'if', 'while', 'for', 'c_for', 'foreach', 'switch', 'try'):
                 result = self._execute_node(child)
@@ -732,6 +735,34 @@ class CSSLRuntime:
         self.scope.set(var_name, instance)
         return instance
 
+    def _exec_instance_declaration(self, node: ASTNode) -> Any:
+        """Execute instance declaration: instance<"name"> varName;
+
+        Gets or creates a shared instance by name.
+        """
+        from ..cssl_bridge import _live_objects, SharedObjectProxy
+        decl = node.value
+        instance_name = decl.get('instance_name')
+        var_name = decl.get('name')
+        value_node = decl.get('value')
+
+        # Get existing shared instance
+        instance = None
+        if instance_name in _live_objects:
+            instance = SharedObjectProxy(instance_name, _live_objects[instance_name])
+        elif f'${instance_name}' in self.global_scope:
+            instance = self.global_scope.get(f'${instance_name}')
+
+        # If value is provided, use that and register as shared
+        if value_node:
+            instance = self._evaluate(value_node)
+            # Register in global scope for future access
+            self.global_scope.set(f'${instance_name}', instance)
+
+        # Store in scope
+        self.scope.set(var_name, instance)
+        return instance
+
     def _exec_global_assignment(self, node: ASTNode) -> Any:
         """Execute global variable assignment: global Name = value
 
@@ -1471,6 +1502,12 @@ class CSSLRuntime:
             name = target.value
             _live_objects[name] = final_value
             self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
+        elif target.type == 'instance_ref':
+            # value ==> instance<"name"> - create/update shared object
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = target.value
+            _live_objects[name] = final_value
+            self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
         elif target.type == 'member_access':
             self._set_member(target, final_value)
 
@@ -1767,6 +1804,20 @@ class CSSLRuntime:
                 return value
             raise CSSLRuntimeError(f"Captured reference '%{name}' not found.")
 
+        if node.type == 'instance_ref':
+            # instance<"name"> - get shared instance by name
+            # Works like $name but with explicit syntax
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = node.value
+            if name in _live_objects:
+                return SharedObjectProxy(name, _live_objects[name])
+            # Check if stored in runtime's scope
+            scoped_val = self.global_scope.get(f'${name}')
+            if scoped_val is not None:
+                return scoped_val
+            # Return None if instance doesn't exist (can be created via ==>)
+            return None
+
         if node.type == 'type_instantiation':
             # Create new instance of a type: stack<string>, vector<int>, etc.
             type_name = node.value.get('type')

{includecpp-3.6.0 → includecpp-3.6.1}/pyproject.toml

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