Merge dev into main

Author: DinisCruz

README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v3.43.0-blue)
+![Current Release](https://img.shields.io/badge/release-v3.43.1-blue)
 ![Python](https://img.shields.io/badge/python-3.8+-green)
 ![Type-Safe](https://img.shields.io/badge/Type--Safe-✓-brightgreen)
 ![Caching](https://img.shields.io/badge/Caching-Built--In-orange)

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Dict.py

@@ -142,3 +142,74 @@ def update(self, other=None, **kwargs):
         # Handle keyword arguments
         for key, value in kwargs.items():
             self[key] = value
+
+    def setdefault(self, key, default=None):
+        if key not in self:
+            self[key] = default  # Delegates to __setitem__ which validates
+        return self[key]
+
+    def __ior__(self, other):
+        # Handle |= operator (Python 3.9+)
+        if hasattr(other, 'items'):
+            for key, value in other.items():
+                self[key] = value  # Delegates to __setitem__ which validates
+        else:
+            for key, value in other:
+                self[key] = value
+        return self
+
+    def copy(self):
+        # Return a copy of the same subclass type, not Type_Safe__Dict
+        result = self.__class__(
+            expected_key_type=self.expected_key_type,
+            expected_value_type=self.expected_value_type
+        )
+        for key, value in self.items():
+            result[key] = value
+        return result
+
+    def __or__(self, other):
+        # Handle | operator (Python 3.9+) - returns new instance of same subclass
+        result = self.__class__(
+            expected_key_type=self.expected_key_type,
+            expected_value_type=self.expected_value_type
+        )
+        for key, value in self.items():
+            result[key] = value
+        if hasattr(other, 'items'):
+            for key, value in other.items():
+                result[key] = value
+        else:
+            for key, value in other:
+                result[key] = value
+        return result
+
+    def __ror__(self, other):
+        # Handle reverse | operator - returns same subclass type
+        result = self.__class__(
+            expected_key_type=self.expected_key_type,
+            expected_value_type=self.expected_value_type
+        )
+        if hasattr(other, 'items'):
+            for key, value in other.items():
+                result[key] = value
+        else:
+            for key, value in other:
+                result[key] = value
+        for key, value in self.items():
+            result[key] = value
+        return result
+
+    @classmethod
+    def fromkeys(cls, keys, value=None, expected_key_type=None, expected_value_type=None):
+        expected_key_type   = expected_key_type   or cls.expected_key_type                          # Use cls to create instance of the actual subclass
+        expected_value_type = expected_value_type or cls.expected_value_type
+
+        if expected_key_type is None or expected_value_type is None:
+            raise ValueError(f"{cls.__name__}.fromkeys() requires expected_key_type and expected_value_type")
+
+        result = cls(expected_key_type   = expected_key_type  ,
+                     expected_value_type = expected_value_type)
+        for key in keys:
+            result[key] = value
+        return result

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__List.py

@@ -7,11 +7,13 @@
 
 
 class Type_Safe__List(Type_Safe__Base, list):
-    expected_type : Type
+    expected_type : Type = None                         # Class-level default
 
-    def __init__(self, expected_type, *args):
+    def __init__(self, expected_type=None, *args):
         super().__init__(*args)
-        self.expected_type = expected_type
+        self.expected_type = expected_type or self.__class__.expected_type
+        if self.expected_type is None:
+            raise ValueError(f"{self.__class__.__name__} requires expected_type")
 
     def __contains__(self, item):
         if super().__contains__(item):                                                                                          # First try direct lookup
@@ -43,37 +45,55 @@ def __repr__(self):
     def __enter__(self): return self
     def __exit__ (self, type, value, traceback): pass
 
-    def append(self, item):
-        from osbot_utils.type_safe.Type_Safe        import Type_Safe                                                                    # to prevent circular imports
+    def _validate_and_convert_item(self, item):     # Validate and convert an item to the expected type."
+        from osbot_utils.type_safe.Type_Safe import Type_Safe
 
-        if type(self.expected_type) is type and issubclass(self.expected_type, Type_Safe) and type(item) is dict:                       # Handle Type_Safe objects from dicts
+        if type(self.expected_type) is type and issubclass(self.expected_type, Type_Safe) and type(item) is dict:
             item = self.expected_type.from_json(item)
-        elif type(self.expected_type) is type and issubclass(self.expected_type, Type_Safe__Primitive):                                 # Handle Type_Safe__Primitive conversions (str -> Safe_Str, etc.)
+        elif type(self.expected_type) is type and issubclass(self.expected_type, Type_Safe__Primitive):
             if not isinstance(item, self.expected_type):
                 try:
                     item = self.expected_type(item)
                 except (ValueError, TypeError) as e:
-                    # Re-raise with more context about what failed
                     raise TypeError(f"In Type_Safe__List: Could not convert {type(item).__name__} to {self.expected_type.__name__}: {e}") from None
 
-        elif hasattr(self.expected_type, '__bases__') and any(base.__name__ == 'Enum' for base in self.expected_type.__bases__):        # Handle Enums
-
+        elif hasattr(self.expected_type, '__bases__') and any(base.__name__ == 'Enum' for base in self.expected_type.__bases__):
             if isinstance(self.expected_type, type) and issubclass(self.expected_type, Enum):
                 if isinstance(item, str):
-                    if item in self.expected_type.__members__:                                                                          # Try to convert string to enum
+                    if item in self.expected_type.__members__:
                         item = self.expected_type[item]
                     elif hasattr(self.expected_type, '_value2member_map_') and item in self.expected_type._value2member_map_:
                         item = self.expected_type._value2member_map_[item]
 
-        try:                                                                                                                            # Now validate the (possibly converted) item
+        try:
             self.is_instance_of_type(item, self.expected_type)
         except TypeError as e:
             raise TypeError(f"In Type_Safe__List: Invalid type for item: {e}") from None
 
+        return item
+
+    def append(self, item):
+        item = self._validate_and_convert_item(item)
         super().append(item)
 
+    def __setitem__(self, index, item):
+        item = self._validate_and_convert_item(item)
+        super().__setitem__(index, item)
+
+    def __iadd__(self, items):
+        for item in items:
+            self.append(item)
+        return self
+
+    def insert(self, index, item):
+        item = self._validate_and_convert_item(item)
+        super().insert(index, item)
 
-    def json(self): # Convert the list to a JSON-serializable format.
+    def extend(self, items):
+        for item in items:
+            self.append(item)
+
+    def json(self):                                                                     # Convert the list to a JSON-serializable format.
         from osbot_utils.type_safe.Type_Safe import Type_Safe                           # Import here to avoid circular imports
 
         result = []
@@ -84,12 +104,56 @@ def json(self): # Convert the list to a JSON-serializable format.
                 result.append(item.__to_primitive__())
             elif isinstance(item, (list, tuple, frozenset)):
                 result.append([x.json() if isinstance(x, Type_Safe) else serialize_to_dict(x) for x in item])
-                #result.append([x.json() if isinstance(x, Type_Safe) else x for x in item])      # BUG here
             elif isinstance(item, dict):
                 result.append(serialize_to_dict(item))          # leverage serialize_to_dict since that method already knows how to handle
-                #result.append({k: v.json() if isinstance(v, Type_Safe) else v for k, v in item.items()})
             elif isinstance(item, type):
                 result.append(class_full_name(item))
             else:
                 result.append(serialize_to_dict(item))          # also Use serialize_to_dict for unknown types (so that we don't return a non json object)
-        return result
+        return result
+
+    def copy(self):
+        # Return a copy of the same subclass type
+        result = self.__class__(expected_type=self.expected_type)
+        for item in self:
+            result.append(item)
+        return result
+
+    def __add__(self, other):
+        # Handle list1 + list2 - returns new instance of same subclass
+        result = self.__class__(expected_type=self.expected_type)
+        for item in self:
+            result.append(item)
+        for item in other:
+            result.append(item)  # Validates each item
+        return result
+
+    def __radd__(self, other):
+        # Handle list + type_safe_list - returns new instance of same subclass
+        result = self.__class__(expected_type=self.expected_type)
+        for item in other:
+            result.append(item)  # Validates each item
+        for item in self:
+            result.append(item)
+        return result
+
+    def __mul__(self, n):
+        # Handle list * n - returns new instance of same subclass
+        result = self.__class__(expected_type=self.expected_type)
+        for _ in range(n):
+            for item in self:
+                result.append(item)
+        return result
+
+    def __rmul__(self, n):
+        # Handle n * list - same as __mul__
+        return self.__mul__(n)
+
+    def __imul__(self, n):
+        # Handle list *= n - modifies in place, type already correct
+        items = list(self)
+        self.clear()
+        for _ in range(n):
+            for item in items:
+                self.append(item)
+        return self

osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Set.py

@@ -1,12 +1,17 @@
+from typing                                     import Type
 from osbot_utils.utils.Objects                  import class_full_name, serialize_to_dict
 from osbot_utils.type_safe.Type_Safe__Base      import Type_Safe__Base, type_str
 from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
 
 
 class Type_Safe__Set(Type_Safe__Base, set):
-    def __init__(self, expected_type, *args):
+    expected_type : Type = None                         # Class-level default
+
+    def __init__(self, expected_type=None, *args):
         super().__init__(*args)
-        self.expected_type = expected_type
+        self.expected_type = expected_type or self.__class__.expected_type
+        if self.expected_type is None:
+            raise ValueError(f"{self.__class__.__name__} requires expected_type")
 
     def __contains__(self, item):
         if super().__contains__(item):                                                                  # First try direct lookup
@@ -65,4 +70,138 @@ def json(self):
     def __eq__(self, other):                                        # todo: see if this is needed
         if isinstance(other, (set, Type_Safe__Set)):
             return set(self) == set(other)
-        return False
+        return False
+
+    def update(self, *others):
+        for other in others:
+            for item in other:
+                self.add(item)  # Delegates to add() which validates
+
+    def copy(self):
+        # Return a copy of the same subclass type
+        result = self.__class__(expected_type=self.expected_type)
+        for item in self:
+            result.add(item)
+        return result
+
+    def __or__(self, other):
+        # Handle | operator - returns new instance of same subclass
+        result = self.__class__(expected_type=self.expected_type)
+        for item in self:
+            result.add(item)
+        for item in other:
+            result.add(item)  # Validates
+        return result
+
+    def __ror__(self, other):
+        # Handle reverse | operator - returns same subclass type
+        result = self.__class__(expected_type=self.expected_type)
+        for item in other:
+            result.add(item)  # Validates
+        for item in self:
+            result.add(item)
+        return result
+
+    def __and__(self, other):
+        # Handle & operator (intersection) - returns same subclass type
+        result = self.__class__(expected_type=self.expected_type)
+        for item in super().__and__(other):
+            result.add(item)
+        return result
+
+    def __rand__(self, other):
+        # Handle reverse & operator
+        return self.__and__(other)
+
+    def __sub__(self, other):
+        # Handle - operator (difference) - returns same subclass type
+        result = self.__class__(expected_type=self.expected_type)
+        for item in super().__sub__(other):
+            result.add(item)
+        return result
+
+    def __rsub__(self, other):
+        # Handle reverse - operator
+        result = self.__class__(expected_type=self.expected_type)
+        for item in set(other) - set(self):
+            result.add(item)  # Validates items from other
+        return result
+
+    def __xor__(self, other):
+        # Handle ^ operator (symmetric difference) - returns same subclass type
+        result = self.__class__(expected_type=self.expected_type)
+        for item in set(self) - set(other):
+            result.add(item)
+        for item in set(other) - set(self):
+            result.add(item)  # Validates
+        return result
+
+    def __rxor__(self, other):
+        # Handle reverse ^ operator
+        return self.__xor__(other)
+
+    def union(self, *others):
+        # Return same subclass type with validation
+        result = self.__class__(expected_type=self.expected_type)
+        for item in self:
+            result.add(item)
+        for other in others:
+            for item in other:
+                result.add(item)  # Validates
+        return result
+
+    def intersection(self, *others):
+        # Return same subclass type
+        result = self.__class__(expected_type=self.expected_type)
+        base_result = set(self)
+        for other in others:
+            base_result &= set(other)
+        for item in base_result:
+            result.add(item)
+        return result
+
+    def difference(self, *others):
+        # Return same subclass type
+        result = self.__class__(expected_type=self.expected_type)
+        base_result = set(self)
+        for other in others:
+            base_result -= set(other)
+        for item in base_result:
+            result.add(item)
+        return result
+
+    def symmetric_difference(self, other):
+        # Return same subclass type with validation for items from other
+        result = self.__class__(expected_type=self.expected_type)
+        for item in set(self) - set(other):
+            result.add(item)
+        for item in set(other) - set(self):
+            result.add(item)  # Validates
+        return result
+
+    def __ior__(self, other):
+        # Handle |= operator
+        for item in other:
+            self.add(item)  # Delegates to add() which validates
+        return self
+
+    def __iand__(self, other):
+        # Handle &= operator (intersection) - only keeps existing valid items
+        super().__iand__(other)
+        return self
+
+    def __isub__(self, other):
+        # Handle -= operator (difference) - only removes items
+        super().__isub__(other)
+        return self
+
+    def __ixor__(self, other):
+        # Handle ^= operator (symmetric difference)
+        # Items from other need validation before being added
+        to_add = set(other) - set(self)
+        to_remove = set(self) & set(other)
+        for item in to_remove:
+            self.discard(item)
+        for item in to_add:
+            self.add(item)  # Validates
+        return self