IncludeCPP 3.5.0__py3-none-any.whl → 3.6.0__py3-none-any.whl

includecpp/core/cssl/cssl_types.py

@@ -546,16 +546,300 @@ class Array(list):
         return len(self)
 
 
+class List(list):
+    """Python-like list with all standard operations.
+
+    Works exactly like Python lists with additional CSSL methods.
+
+    Usage:
+        list myList;
+        myList.append("item");
+        myList.insert(0, "first");
+        myList.pop();
+        myList.find("item");  # Returns index or -1
+    """
+
+    def __init__(self, element_type: str = 'dynamic'):
+        super().__init__()
+        self._element_type = element_type
+
+    def length(self) -> int:
+        """Return list length"""
+        return len(self)
+
+    def size(self) -> int:
+        """Return list size (alias for length)"""
+        return len(self)
+
+    def isEmpty(self) -> bool:
+        """Check if list is empty"""
+        return len(self) == 0
+
+    def first(self) -> Any:
+        """Get first element"""
+        return self[0] if self else None
+
+    def last(self) -> Any:
+        """Get last element"""
+        return self[-1] if self else None
+
+    def at(self, index: int) -> Any:
+        """Get item at index (safe access)"""
+        if 0 <= index < len(self):
+            return self[index]
+        return None
+
+    def set(self, index: int, value: Any) -> 'List':
+        """Set item at index"""
+        if 0 <= index < len(self):
+            self[index] = value
+        return self
+
+    def add(self, item: Any) -> 'List':
+        """Add item to end (alias for append)"""
+        self.append(item)
+        return self
+
+    def push(self, item: Any) -> 'List':
+        """Push item to end (alias for append)"""
+        self.append(item)
+        return self
+
+    def find(self, item: Any) -> int:
+        """Find index of item (-1 if not found)"""
+        try:
+            return self.index(item)
+        except ValueError:
+            return -1
+
+    def contains(self, item: Any) -> bool:
+        """Check if list contains item"""
+        return item in self
+
+    def indexOf(self, item: Any) -> int:
+        """Find index of item (-1 if not found)"""
+        return self.find(item)
+
+    def lastIndexOf(self, item: Any) -> int:
+        """Find last index of item (-1 if not found)"""
+        for i in range(len(self) - 1, -1, -1):
+            if self[i] == item:
+                return i
+        return -1
+
+    def removeAt(self, index: int) -> Any:
+        """Remove and return item at index"""
+        if 0 <= index < len(self):
+            return self.pop(index)
+        return None
+
+    def removeValue(self, value: Any) -> bool:
+        """Remove first occurrence of value"""
+        try:
+            self.remove(value)
+            return True
+        except ValueError:
+            return False
+
+    def removeAll(self, value: Any) -> int:
+        """Remove all occurrences of value, return count"""
+        count = 0
+        while value in self:
+            self.remove(value)
+            count += 1
+        return count
+
+    def slice(self, start: int, end: int = None) -> 'List':
+        """Return slice of list"""
+        result = List(self._element_type)
+        if end is None:
+            result.extend(self[start:])
+        else:
+            result.extend(self[start:end])
+        return result
+
+    def join(self, separator: str = ',') -> str:
+        """Join elements into string"""
+        return separator.join(str(item) for item in self)
+
+    def unique(self) -> 'List':
+        """Return list with unique elements"""
+        result = List(self._element_type)
+        seen = set()
+        for item in self:
+            key = item if isinstance(item, (int, str, float, bool)) else id(item)
+            if key not in seen:
+                seen.add(key)
+                result.append(item)
+        return result
+
+    def sorted(self, reverse: bool = False) -> 'List':
+        """Return sorted copy"""
+        result = List(self._element_type)
+        result.extend(sorted(self, reverse=reverse))
+        return result
+
+    def reversed(self) -> 'List':
+        """Return reversed copy"""
+        result = List(self._element_type)
+        result.extend(reversed(self))
+        return result
+
+    def shuffle(self) -> 'List':
+        """Shuffle list in place"""
+        import random
+        random.shuffle(self)
+        return self
+
+    def fill(self, value: Any, count: int = None) -> 'List':
+        """Fill list with value"""
+        if count is None:
+            for i in range(len(self)):
+                self[i] = value
+        else:
+            self.clear()
+            self.extend([value] * count)
+        return self
+
+    def begin(self) -> int:
+        """Return iterator to beginning"""
+        return 0
+
+    def end(self) -> int:
+        """Return iterator to end"""
+        return len(self)
+
+
+class Dictionary(dict):
+    """Python-like dictionary with all standard operations.
+
+    Works exactly like Python dicts with additional CSSL methods.
+
+    Usage:
+        dictionary myDict;
+        myDict.set("key", "value");
+        myDict.get("key");
+        myDict.keys();
+        myDict.values();
+    """
+
+    def __init__(self, key_type: str = 'dynamic', value_type: str = 'dynamic'):
+        super().__init__()
+        self._key_type = key_type
+        self._value_type = value_type
+
+    def length(self) -> int:
+        """Return dictionary size"""
+        return len(self)
+
+    def size(self) -> int:
+        """Return dictionary size (alias for length)"""
+        return len(self)
+
+    def isEmpty(self) -> bool:
+        """Check if dictionary is empty"""
+        return len(self) == 0
+
+    def set(self, key: Any, value: Any) -> 'Dictionary':
+        """Set key-value pair"""
+        self[key] = value
+        return self
+
+    def hasKey(self, key: Any) -> bool:
+        """Check if key exists"""
+        return key in self
+
+    def hasValue(self, value: Any) -> bool:
+        """Check if value exists"""
+        return value in self.values()
+
+    def remove(self, key: Any) -> Any:
+        """Remove and return value for key"""
+        return self.pop(key, None)
+
+    def getOrDefault(self, key: Any, default: Any = None) -> Any:
+        """Get value or default if not found"""
+        return self.get(key, default)
+
+    def setDefault(self, key: Any, default: Any) -> Any:
+        """Set default if key doesn't exist, return value"""
+        if key not in self:
+            self[key] = default
+        return self[key]
+
+    def merge(self, other: dict) -> 'Dictionary':
+        """Merge another dictionary into this one"""
+        self.update(other)
+        return self
+
+    def keysList(self) -> list:
+        """Return keys as list"""
+        return list(self.keys())
+
+    def valuesList(self) -> list:
+        """Return values as list"""
+        return list(self.values())
+
+    def itemsList(self) -> list:
+        """Return items as list of tuples"""
+        return list(self.items())
+
+    def filter(self, predicate: Callable[[Any, Any], bool]) -> 'Dictionary':
+        """Filter dictionary by predicate(key, value)"""
+        result = Dictionary(self._key_type, self._value_type)
+        for k, v in self.items():
+            if predicate(k, v):
+                result[k] = v
+        return result
+
+    def map(self, func: Callable[[Any, Any], Any]) -> 'Dictionary':
+        """Apply function to all values"""
+        result = Dictionary(self._key_type, self._value_type)
+        for k, v in self.items():
+            result[k] = func(k, v)
+        return result
+
+    def forEach(self, func: Callable[[Any, Any], None]) -> 'Dictionary':
+        """Execute function for each key-value pair"""
+        for k, v in self.items():
+            func(k, v)
+        return self
+
+    def invert(self) -> 'Dictionary':
+        """Swap keys and values"""
+        result = Dictionary(self._value_type, self._key_type)
+        for k, v in self.items():
+            result[v] = k
+        return result
+
+    def find(self, value: Any) -> Optional[Any]:
+        """Find first key with given value"""
+        for k, v in self.items():
+            if v == value:
+                return k
+        return None
+
+    def findAll(self, value: Any) -> list:
+        """Find all keys with given value"""
+        return [k for k, v in self.items() if v == value]
+
+
 class Shuffled(list):
     """Unorganized fast storage for multiple returns.
 
     Stores data unorganized for fast and efficient access.
     Supports receiving multiple return values from functions.
+    Can be used as a function modifier to allow multiple returns.
 
     Usage:
         shuffled<string> results;
         results +<== someFunc();  # Catches all returns
         results.read()  # Returns all content as list
+
+        # As return modifier:
+        shuffled string getData() {
+            return "name", "address";  # Returns multiple values
+        }
     """
 
     def __init__(self, element_type: str = 'dynamic'):
@@ -575,6 +859,49 @@ class Shuffled(list):
             self.append(result)
         return self
 
+    def add(self, *items) -> 'Shuffled':
+        """Add one or more items"""
+        for item in items:
+            if isinstance(item, (list, tuple)):
+                self.extend(item)
+            else:
+                self.append(item)
+        return self
+
+    def first(self) -> Any:
+        """Get first element"""
+        return self[0] if self else None
+
+    def last(self) -> Any:
+        """Get last element"""
+        return self[-1] if self else None
+
+    def length(self) -> int:
+        """Return shuffled length"""
+        return len(self)
+
+    def isEmpty(self) -> bool:
+        """Check if empty"""
+        return len(self) == 0
+
+    def contains(self, item: Any) -> bool:
+        """Check if contains item"""
+        return item in self
+
+    def at(self, index: int) -> Any:
+        """Get item at index"""
+        if 0 <= index < len(self):
+            return self[index]
+        return None
+
+    def toList(self) -> list:
+        """Convert to plain list"""
+        return list(self)
+
+    def toTuple(self) -> tuple:
+        """Convert to tuple"""
+        return tuple(self)
+
 
 class Iterator:
     """Advanced iterator with programmable tasks.
@@ -944,10 +1271,20 @@ def create_array(element_type: str = 'dynamic') -> Array:
     return Array(element_type)
 
 
+def create_list(element_type: str = 'dynamic') -> List:
+    """Create a List object"""
+    return List(element_type)
+
+
+def create_dictionary(key_type: str = 'dynamic', value_type: str = 'dynamic') -> Dictionary:
+    """Create a Dictionary object"""
+    return Dictionary(key_type, value_type)
+
+
 __all__ = [
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array',
+    'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array', 'List', 'Dictionary',
     'create_datastruct', 'create_shuffled', 'create_iterator',
     'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
-    'create_stack', 'create_vector', 'create_array'
+    'create_stack', 'create_vector', 'create_array', 'create_list', 'create_dictionary'
 ]

includecpp/core/cssl_bridge.py

@@ -429,7 +429,7 @@ class CsslLang:
             runtime._inline_payloads = {}
         runtime._inline_payloads[name] = code
 
-    def share(self, instance: Any, name: str) -> str:
+    def share(self, instance: Any, name: str = None) -> str:
         """
         Share a Python object instance with CSSL scripts (LIVE sharing).
 
@@ -437,6 +437,14 @@ class CsslLang:
         will be reflected in the original Python object immediately.
         Call share() again with the same name to update the shared object.
 
+        Args:
+            instance: The Python object to share (or name if using old API)
+            name: The name to reference the object in CSSL ($name)
+
+        Note: Arguments can be passed in either order:
+            cssl.share(my_object, "name")  # Preferred
+            cssl.share("name", my_object)  # Also works
+
         Usage in Python:
             from includecpp import CSSL
             cssl = CSSL.CsslLang()
@@ -474,6 +482,21 @@ class CsslLang:
         global _live_objects
         runtime = self._get_runtime()
 
+        # Handle argument order flexibility: share(instance, name) or share(name, instance)
+        if name is None:
+            # Only one argument - use object type as name
+            name = type(instance).__name__
+        elif isinstance(instance, str) and not isinstance(name, str):
+            # Arguments are swapped: share("name", instance) -> swap them
+            instance, name = name, instance
+        elif not isinstance(name, str):
+            # name is not a string - use its type as name
+            name = type(name).__name__
+
+        # Sanitize filename: remove invalid characters for Windows
+        import re
+        safe_name = re.sub(r'[<>:"/\\|?*\x00-\x1f]', '_', str(name))
+
         # Initialize shared objects registry
         if not hasattr(runtime, '_shared_objects'):
             runtime._shared_objects = {}
@@ -481,7 +504,7 @@ class CsslLang:
         # Generate unique filename: <name>.shareobj<7digits>
         random_suffix = ''.join([str(random.randint(0, 9)) for _ in range(7)])
         share_dir = _get_share_directory()
-        filepath = share_dir / f"{name}.shareobj{random_suffix}"
+        filepath = share_dir / f"{safe_name}.shareobj{random_suffix}"
 
         # Remove old file if updating
         if name in runtime._shared_objects:
@@ -577,22 +600,65 @@ class CsslLang:
 
         return None
 
+    def shared(self, name: str) -> Optional[Any]:
+        """
+        Get a shared object by name (alias for get_shared).
+
+        Returns the actual live object reference, not a copy.
+        Works with both Python cssl.share() and CSSL ==> $name shared objects.
+
+        Usage:
+            from includecpp import CSSL
+            cssl = CSSL.CsslLang()
+
+            # Share an object
+            my_obj = {"value": 42}
+            cssl.share(my_obj, "data")
+
+            # Retrieve it later
+            obj = cssl.shared("data")
+            print(obj["value"])  # 42
+
+        Args:
+            name: Name of the shared object (without $ prefix)
+
+        Returns:
+            The live shared object or None if not found
+        """
+        return self.get_shared(name)
+
 
 # Global shared objects registry (for cross-instance sharing)
 _global_shared_objects: Dict[str, str] = {}
 
 
-def share(instance: Any, name: str) -> str:
+def share(instance: Any, name: str = None) -> str:
     """
     Share a Python object globally for all CSSL instances (LIVE sharing).
 
     Changes made through CSSL will reflect back to the original object.
+
+    Args can be passed in either order:
+        share(my_object, "name")  # Preferred
+        share("name", my_object)  # Also works
     """
     global _live_objects
+    import re
+
+    # Handle argument order flexibility
+    if name is None:
+        name = type(instance).__name__
+    elif isinstance(instance, str) and not isinstance(name, str):
+        instance, name = name, instance
+    elif not isinstance(name, str):
+        name = type(name).__name__
+
+    # Sanitize filename
+    safe_name = re.sub(r'[<>:"/\\|?*\x00-\x1f]', '_', str(name))
 
     random_suffix = ''.join([str(random.randint(0, 9)) for _ in range(7)])
     share_dir = _get_share_directory()
-    filepath = share_dir / f"{name}.shareobj{random_suffix}"
+    filepath = share_dir / f"{safe_name}.shareobj{random_suffix}"
 
     # Remove old file if updating
     if name in _global_shared_objects:
@@ -645,6 +711,32 @@ def get_shared(name: str) -> Optional[Any]:
     return _live_objects.get(name)
 
 
+def shared(name: str) -> Optional[Any]:
+    """
+    Get a shared object by name (alias for get_shared).
+
+    Works with both Python share() and CSSL ==> $name shared objects.
+
+    Usage:
+        from includecpp import CSSL
+
+        # Share an object
+        my_obj = {"value": 42}
+        CSSL.share(my_obj, "data")
+
+        # Retrieve it later
+        obj = CSSL.shared("data")
+        print(obj["value"])  # 42
+
+    Args:
+        name: Name of the shared object (without $ prefix)
+
+    Returns:
+        The live shared object or None if not found
+    """
+    return get_shared(name)
+
+
 # Singleton for convenience
 _default_instance: Optional[CsslLang] = None
 
@@ -783,4 +875,8 @@ __all__ = [
     'clear_output',
     'module',
     'makemodule',
+    'share',
+    'unshare',
+    'shared',
+    'get_shared',
 ]