osbot-utils 2.10.0__tar.gz → 2.12.0__tar.gz

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.10.0
+Version: 2.12.0
 Summary: OWASP Security Bot - Utils
-Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
 Author: Dinis Cruz
 Author-email: dinis.cruz@owasp.org
@@ -16,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Project-URL: Homepage, https://github.com/owasp-sbot/OSBot-Utils
 Project-URL: Repository, https://github.com/owasp-sbot/OSBot-Utils
 Description-Content-Type: text/markdown
 
@@ -23,7 +23,7 @@ Description-Content-Type: text/markdown
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v2.10.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.12.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/README.md

@@ -2,7 +2,7 @@
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v2.10.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.12.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

osbot_utils-2.12.0/osbot_utils/context_managers/capture_duration.py

@@ -0,0 +1,37 @@
+import time
+
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+
+class capture_duration(Type_Safe):
+    action_name : str
+    duration    : float
+    start_time  : float
+    end_time    : float
+    seconds     : float
+    precision   : int = 3                                       # Default rounding to 3 decimal places
+
+
+    def __enter__(self):
+        self.start_time = time.perf_counter()                   # Start the performance counter
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.end_time = time.perf_counter()                     # End the performance counter
+        self.duration = self.end_time - self.start_time
+        self.seconds = round(self.duration, self.precision)     # Use configurable precision
+        return False                                            # Ensures that exceptions are rethrown
+
+    def data(self):
+        return {
+            "start": self.start_time,
+            "end": self.end_time,
+            "seconds": self.seconds,
+        }
+
+    def print(self):
+        print()
+        if self.action_name:
+            print(f'action "{self.action_name}" took: {self.seconds} seconds')
+        else:
+            print(f'action took: {self.seconds} seconds')

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/helpers/CPrint.py

@@ -1,4 +1,3 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
 from osbot_utils.helpers.CFormat import CFormat, CFormat_Colors
 
 

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/helpers/trace/Trace_Call.py

@@ -1,8 +1,7 @@
 import linecache
 import sys
 import threading
-from functools import wraps
-
+from functools                                              import wraps
 from osbot_utils.base_classes.Kwargs_To_Self                import Kwargs_To_Self
 from osbot_utils.helpers.trace.Trace_Call__Config           import Trace_Call__Config, PRINT_MAX_STRING_LENGTH
 from osbot_utils.helpers.trace.Trace_Call__Handler          import Trace_Call__Handler

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/helpers/trace/Trace_Call__Handler.py

@@ -8,29 +8,29 @@ from osbot_utils.helpers.trace.Trace_Call__Stack_Node   import Trace_Call__Stack
 from osbot_utils.helpers.trace.Trace_Call__Stats        import Trace_Call__Stats
 
 DEFAULT_ROOT_NODE_NODE_TITLE = 'Trace Session'
-GLOBAL_FUNCTIONS_TO_IGNORE   = ['value_type_matches_obj_annotation_for_attr'                ,            # these are type safety functions which introduce quite a lot of noise in the traces (and unless one is debugging type safety, they will not be needed)
-                                'value_type_matches_obj_annotation_for_union_and_annotated' ,            # todo: map out and document why exactly these methods are ignore (and what is the side effect)
-                                'are_types_compatible_for_assigment'                        ,
-                                'obj_attribute_annotation'                                  ,
-                                'all_annotations'                                           ,
-                                'get_origin'                                                ,
-                                'getmro'                                                    ,
-                                'default_value'                                             ,
-                                'raise_exception_on_obj_type_annotation_mismatch'           ,
-                                '__cls_kwargs__'                                            ,
-                                '__default__value__'                                        ,
-                                '__setattr__'                                               ,
-                                '<module>']
+# GLOBAL_FUNCTIONS_TO_IGNORE   = ['value_type_matches_obj_annotation_for_attr'                ,            # these are type safety functions which introduce quite a lot of noise in the traces (and unless one is debugging type safety, they will not be needed)
+#                                 'value_type_matches_obj_annotation_for_union_and_annotated' ,            # todo: map out and document why exactly these methods are ignore (and what is the side effect)
+#                                 'are_types_compatible_for_assigment'                        ,
+#                                 'obj_attribute_annotation'                                  ,
+#                                 'all_annotations'                                           ,
+#                                 'get_origin'                                                ,
+#                                 'getmro'                                                    ,
+#                                 'default_value'                                             ,
+#                                 '__cls_kwargs__'                                            ,
+#                                 '__default__value__'                                        ,
+#                                 '__setattr__'                                               ,
+#                                 '<module>']
 GLOBAL_MODULES_TO_IGNORE     = ['osbot_utils.helpers.trace.Trace_Call'                      ,            # todo: map out and document why exactly these modules are ignore (and what is the side effect)
                                 'osbot_utils.helpers.trace.Trace_Call__Config'              ,
                                 'osbot_utils.helpers.trace.Trace_Call__View_Model'          ,
                                 'osbot_utils.helpers.trace.Trace_Call__Print_Traces'        ,
                                 'osbot_utils.helpers.trace.Trace_Call__Stack'               ,
-                                'osbot_utils.base_classes.Type_Safe'                        ,
+                               # 'osbot_utils.base_classes.Type_Safe'                        ,
                                 'osbot_utils.helpers.CPrint'                                ,            #       also see if this should be done here or at the print/view stage
                                 'osbot_utils.helpers.Print_Table'                           ,
                                 'osbot_utils.decorators.methods.cache_on_self'              ,
                                 'codecs'                                                    ]
+GLOBAL_FUNCTIONS_TO_IGNORE = []
 
 #GLOBAL_MODULES_TO_IGNORE = []
 #GLOBAL_FUNCTIONS_TO_IGNORE = []

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/helpers/xml/Xml__File.py

@@ -1,5 +1,5 @@
 from typing                                 import Dict
-from osbot_utils.type_safe.Type_Safe     import Type_Safe
+from osbot_utils.type_safe.Type_Safe        import Type_Safe
 from osbot_utils.helpers.xml.Xml__Element   import XML__Element
 
 class Xml__File(Type_Safe):

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/helpers/xml/Xml__File__To_Dict.py

@@ -1,5 +1,5 @@
 from typing                                 import Dict, Any
-from osbot_utils.type_safe.Type_Safe     import Type_Safe
+from osbot_utils.type_safe.Type_Safe        import Type_Safe
 from osbot_utils.helpers.xml.Xml__Element   import XML__Element
 from osbot_utils.helpers.xml.Xml__File      import Xml__File
 

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/helpers/xml/Xml__File__To_Xml.py

@@ -1,7 +1,7 @@
 from typing                                 import Optional
 from xml.etree.ElementTree                  import Element, SubElement, tostring
 from xml.dom                                import minidom
-from osbot_utils.type_safe.Type_Safe     import Type_Safe
+from osbot_utils.type_safe.Type_Safe        import Type_Safe
 from osbot_utils.helpers.xml.Xml__Element   import XML__Element
 from osbot_utils.helpers.xml.Xml__File      import Xml__File
 

osbot_utils-2.12.0/osbot_utils/testing/performance/Performance_Measure__Session.py

@@ -0,0 +1,108 @@
+import time
+from typing                                                                         import Callable, List
+from statistics                                                                     import mean, median, stdev
+from osbot_utils.utils.Env                                                          import in_github_action
+from osbot_utils.testing.performance.models.Model__Performance_Measure__Measurement import Model__Performance_Measure__Measurement
+from osbot_utils.testing.performance.models.Model__Performance_Measure__Result      import Model__Performance_Measure__Result
+from osbot_utils.type_safe.Type_Safe                                                import Type_Safe
+
+MEASURE__INVOCATION__LOOPS = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]            # Fibonacci sequence for measurement loops
+
+class Performance_Measure__Session(Type_Safe):
+    result        : Model__Performance_Measure__Result = None                                          # Current measurement result
+    assert_enabled: bool = True
+
+    def calculate_raw_score(self, times: List[int]) -> int:                                     # Calculate raw performance score
+        if len(times) < 3:                                                                      # Need at least 3 values for stability
+            return mean(times)
+
+        sorted_times = sorted(times)                                                            # Sort times for analysis
+        trim_size    = max(1, len(times) // 10)                                                 # Remove ~10% from each end
+
+        trimmed      = sorted_times[trim_size:-trim_size]                                       # Remove outliers
+        med          = median(trimmed)                                                          # Get median of trimmed data
+        trimmed_mean = mean  (trimmed)                                                          # Get mean of trimmed data
+
+        raw_score = int(med * 0.6 + trimmed_mean * 0.4)                                         # Weighted combination favoring median
+        return raw_score
+
+    def calculate_stable_score(self, raw_score: float) -> int:                                  # Calculate stable performance score
+        if raw_score < 1_000:                                                                   # Dynamic normalization based on score magnitude
+            return int(round(raw_score / 100) * 100)                                            # Under 1µs: nearest 100ns
+        elif raw_score < 10_000:
+            return int(round(raw_score / 1000) * 1000)                                          # Under 10µs: nearest 500ns
+        elif raw_score < 100_000:
+            return int(round(raw_score / 10000) * 10000)                                        # Under 100µs: nearest 1000ns
+        else:
+            return int(round(raw_score / 100000) * 100000)                                        # Above 100µs: nearest 5000ns
+
+    def calculate_metrics(self, times: List[int]) -> Model__Performance_Measure__Measurement:   # Calculate statistical metrics
+        if not times:
+            raise ValueError("Cannot calculate metrics from empty time list")
+        raw_score = self.calculate_raw_score   (times)
+        score     = self.calculate_stable_score(raw_score)
+        return Model__Performance_Measure__Measurement(
+            avg_time    = int(mean(times))                                                  ,
+            min_time    = min(times)                                        ,
+            max_time    = max(times)                                        ,
+            median_time = int(median(times))                                ,
+            stddev_time = stdev(times) if len(times) > 1 else 0             ,
+            raw_times   = times                                             ,
+            sample_size = len(times)                                        ,
+            raw_score   = raw_score                                         ,
+            score       = score                                             )
+
+    def measure(self, target: Callable) -> 'Performance_Measure__Session':               # Perform measurements
+        name         = target.__name__
+        measurements = {}
+        all_times    = []                                                                    # Collect all times for final score
+
+        for loop_size in MEASURE__INVOCATION__LOOPS:                                        # Measure each loop size
+            loop_times = []
+            for i in range(loop_size):
+                start = time.perf_counter_ns()
+                target()
+                end   = time.perf_counter_ns()
+                time_taken = end - start
+                loop_times.append(time_taken)
+                all_times.append(time_taken)                                                 # Add to overall collection
+
+            measurements[loop_size] = self.calculate_metrics(loop_times)                     # Store metrics for this loop size
+
+        raw_score    = self.calculate_raw_score  (all_times)
+        final_score = self.calculate_stable_score(raw_score)                                # Calculate final stable score
+
+        self.result = Model__Performance_Measure__Result(
+            measurements = measurements                                                      ,
+            name        = name                                                              ,
+            raw_score   = raw_score                                                         ,
+            final_score = final_score                                                       )
+
+        return self
+
+    def print_measurement(self, measurement: Model__Performance_Measure__Measurement):       # Format measurement details
+        print(f"Samples : {measurement.sample_size}")
+        print(f"Score   : {measurement.score:,.0f}ns")
+        print(f"Avg     : {measurement.avg_time:,}ns")
+        print(f"Min     : {measurement.min_time:,}ns")
+        print(f"Max     : {measurement.max_time:,}ns")
+        print(f"Median  : {measurement.median_time:,}ns")
+        print(f"StdDev  : {measurement.stddev_time:,.2f}ns")
+
+    def print(self, padding=12 ):                                                # Print measurement results
+        if not self.result:
+            print("No measurements taken yet")
+            return
+        print(f"{self.result.name:{padding}} | score: {self.result.final_score:7,d} ns  | raw: {self.result.raw_score:7,d} ns")          # Print name and normalized score
+
+        return self
+
+    def assert_time(self, *expected_time: int):                                              # Assert that the final score matches the expected normalized time"""
+        if self.assert_enabled is False:
+            return
+        if in_github_action():
+            last_expected_time = expected_time[-1] + 100                                    # +100 in case it is 0
+            new_expected_time   = last_expected_time * 5                                    # using last_expected_time * 5 as the upper limit (since these tests are significantly slowed in GitHUb Actions)
+            assert last_expected_time <=  self.result.final_score <= new_expected_time, f"Performance changed for {self.result.name}: expected {last_expected_time} < {self.result.final_score:,d}ns, expected {new_expected_time}"
+        else:
+            assert self.result.final_score in expected_time,  f"Performance changed for {self.result.name}: got {self.result.final_score:,d}ns, expected {expected_time}"

osbot_utils-2.12.0/osbot_utils/testing/performance/models/Model__Performance_Measure__Measurement.py

@@ -0,0 +1,14 @@
+from typing                             import List
+from osbot_utils.type_safe.Type_Safe    import Type_Safe
+
+
+class Model__Performance_Measure__Measurement(Type_Safe):                                     # Pure data container for measurement metrics
+    avg_time     : int                                                                       # Average time in nanoseconds
+    min_time     : int                                                                       # Minimum time observed
+    max_time     : int                                                                       # Maximum time observed
+    median_time  : int                                                                       # Median time
+    stddev_time  : float                                                                     # Standard deviation
+    raw_times    : List[int]                                                                 # Raw measurements for analysis
+    sample_size  : int                                                                       # Number of measurements taken
+    score        : float
+    raw_score    : float

osbot_utils-2.12.0/osbot_utils/testing/performance/models/Model__Performance_Measure__Result.py

@@ -0,0 +1,10 @@
+from typing                                                                         import Dict
+from osbot_utils.testing.performance.models.Model__Performance_Measure__Measurement import Model__Performance_Measure__Measurement
+from osbot_utils.type_safe.Type_Safe                                                import Type_Safe
+
+class Model__Performance_Measure__Result(Type_Safe):                                         # Pure data container for measurement results
+    measurements : Dict[int, Model__Performance_Measure__Measurement]                        # Results per loop size
+    name         : str                                                                       # Name of measured target
+    raw_score    : float
+    final_score  : float
+

osbot_utils-2.12.0/osbot_utils/type_safe/Type_Safe.py

@@ -0,0 +1,109 @@
+# todo: find a way to add these documentations strings to a separate location so that
+#       the data is available in IDE's code complete
+from osbot_utils.type_safe.shared.Type_Safe__Validation             import type_safe_validation
+from osbot_utils.type_safe.steps.Type_Safe__Step__Class_Kwargs      import type_safe_step_class_kwargs
+from osbot_utils.type_safe.steps.Type_Safe__Step__Default_Kwargs    import type_safe_step_default_kwargs
+from osbot_utils.type_safe.steps.Type_Safe__Step__Default_Value     import type_safe_step_default_value
+from osbot_utils.type_safe.steps.Type_Safe__Step__Init              import type_safe_step_init
+from osbot_utils.type_safe.steps.Type_Safe__Step__Set_Attr          import type_safe_step_set_attr
+from osbot_utils.utils.Objects                                      import serialize_to_dict
+
+class Type_Safe:
+
+    def __init__(self, **kwargs):
+
+        class_kwargs = self.__cls_kwargs__()
+        type_safe_step_init.init(self, class_kwargs, **kwargs)
+
+
+    def __enter__(self): return self
+    def __exit__(self, exc_type, exc_val, exc_tb): pass
+
+    def __setattr__(self, name, value):
+        type_safe_step_set_attr.setattr(super(), self, name, value)
+
+    def __attr_names__(self):
+        from osbot_utils.utils.Misc import list_set
+
+        return list_set(self.__locals__())
+
+    @classmethod
+    def __cls_kwargs__(cls):                                                # Return current class dictionary of class level variables and their values
+        return type_safe_step_class_kwargs.get_cls_kwargs(cls)
+
+    @classmethod
+    def __default__value__(cls, var_type):
+        return type_safe_step_default_value.default_value(cls, var_type)
+
+    def __default_kwargs__(self):                                           # Return entire (including base classes) dictionary of class level variables and their values.
+        return type_safe_step_default_kwargs.default_kwargs(self)
+
+    def __kwargs__(self):                                                   # Return a dictionary of the current instance's attribute values including inherited class defaults.
+        return type_safe_step_default_kwargs.kwargs(self)
+
+
+    def __locals__(self):                                                   # Return a dictionary of the current instance's attribute values.
+        return type_safe_step_default_kwargs.locals(self)
+
+    # global methods added to any class that base classes this
+    # todo: see if there should be a prefix on these methods, to make it easier to spot them
+    #       of if these are actually that useful that they should be added like this
+    # todo: these methods should not be here
+    # def bytes(self):
+    #     from osbot_utils.utils.Json import json_to_bytes
+    #
+    #     return json_to_bytes(self.json())
+    #
+    # def bytes_gz(self):
+    #     from osbot_utils.utils.Json import json_to_gz
+    #
+    #     return json_to_gz(self.json())
+
+    def json(self):
+        return self.serialize_to_dict()
+
+    # todo: see if we still need this. now that Type_Safe handles base types, there should be no need for this
+    def merge_with(self, target):
+        original_attrs = {k: v for k, v in self.__dict__.items() if k not in target.__dict__}       # Store the original attributes of self that should be retained.
+        self.__dict__ = target.__dict__                                                             # Set the target's __dict__ to self, now self and target share the same __dict__.
+        self.__dict__.update(original_attrs)                                                        # Reassign the original attributes back to self.
+        return self
+
+    # def locked(self, value=True):                                   # todo: figure out best way to do this (maybe???)
+    #     self.__lock_attributes__ = value                            #     : update, with the latest changes were we don't show internals on __locals__() this might be a good way to do this
+    #     return self
+
+    def reset(self):
+        for k,v in self.__cls_kwargs__().items():
+            setattr(self, k, v)
+
+    # todo: see if we still need this here in this class
+    def update_from_kwargs(self, **kwargs):                         # Update instance attributes with values from provided keyword arguments.
+
+        for key, value in kwargs.items():
+            if value is not None:
+                if hasattr(self,'__annotations__'):  # can only do type safety checks if the class does not have annotations
+                    if type_safe_validation.check_if__type_matches__obj_annotation__for_attr(self, key, value) is False:
+                        raise ValueError(f"Invalid type for attribute '{key}'. Expected '{self.__annotations__.get(key)}' but got '{type(value)}'")
+                setattr(self, key, value)
+        return self
+
+    def obj(self):
+        from osbot_utils.utils.Objects import dict_to_obj
+
+        return dict_to_obj(self.json())
+
+    def serialize_to_dict(self):                        # todo: see if we need this method or if the .json() is enough
+        return serialize_to_dict(self)
+
+    def print(self):
+        from osbot_utils.utils.Dev import pprint
+
+        pprint(serialize_to_dict(self))
+
+    @classmethod
+    def from_json(cls, json_data, raise_on_not_found=False):
+        from osbot_utils.type_safe.steps.Type_Safe__Step__From_Json import type_safe_step_from_json     # circular dependency on Type_Safe
+        return type_safe_step_from_json.from_json(cls, json_data, raise_on_not_found)
+
+

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/type_safe/Type_Safe__Base.py

@@ -1,4 +1,6 @@
-from typing import get_origin, get_args, Union, Optional, Any, ForwardRef
+from typing import get_args, Union, Optional, Any, ForwardRef
+
+from osbot_utils.type_safe.shared.Type_Safe__Cache import type_safe_cache
 
 EXACT_TYPE_MATCH = (int, float, str, bytes, bool, complex)
 
@@ -8,7 +10,7 @@ class Type_Safe__Base:
             return True
         if isinstance(expected_type, ForwardRef):               # todo: add support for ForwardRef
             return True
-        origin = get_origin(expected_type)
+        origin = type_safe_cache.get_origin(expected_type)
         args   = get_args(expected_type)
         if origin is None:
             if expected_type in EXACT_TYPE_MATCH:
@@ -85,12 +87,12 @@ class Type_Safe__Base:
                 actual_type_name = type_str(type(item))
                 raise TypeError(f"Expected '{expected_type_name}', but got '{actual_type_name}'")
 
-    def json(self):
-        raise NotImplemented
+    # def json(self):
+    #     pass
 
 # todo: see if we should/can move this to the Objects.py file
 def type_str(tp):
-    origin = get_origin(tp)
+    origin = type_safe_cache.get_origin(tp)
     if origin is None:
         if hasattr(tp, '__name__'):
             return tp.__name__
@@ -99,22 +101,4 @@ def type_str(tp):
     else:
         args = get_args(tp)
         args_str = ', '.join(type_str(arg) for arg in args)
-        return f"{origin.__name__}[{args_str}]"
-
-def get_object_type_str(obj):
-    if isinstance(obj, dict):
-        if not obj:
-            return "Dict[Empty]"
-        key_types      = set(type(k).__name__ for k in obj.keys())
-        value_types    = set(type(v).__name__ for v in obj.values())
-        key_type_str   = ', '.join(sorted(key_types))
-        value_type_str = ', '.join(sorted(value_types))
-        return f"Dict[{key_type_str}, {value_type_str}]"
-    elif isinstance(obj, list):
-        if not obj:
-            return "List[Empty]"
-        elem_types = set(type(e).__name__ for e in obj)
-        elem_type_str = ', '.join(sorted(elem_types))
-        return f"List[{elem_type_str}]"
-    else:
-        return type(obj).__name__
+        return f"{origin.__name__}[{args_str}]"

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/type_safe/Type_Safe__Dict.py

@@ -1,4 +1,4 @@
-from osbot_utils.type_safe.Type_Safe__Base import type_str, Type_Safe__Base
+from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base
 
 class Type_Safe__Dict(Type_Safe__Base, dict):
     def __init__(self, expected_key_type, expected_value_type, *args, **kwargs):
@@ -7,19 +7,20 @@ class Type_Safe__Dict(Type_Safe__Base, dict):
         self.expected_key_type   = expected_key_type
         self.expected_value_type = expected_value_type
 
-        for k, v in self.items():                           # check type-safety of ctor arguments
-            self.is_instance_of_type(k, self.expected_key_type  )
-            self.is_instance_of_type(v, self.expected_value_type)
+        # todo: see if we need to do this, since there was not code coverage hitting it
+        # for k, v in self.items():                           # check type-safety of ctor arguments
+        #     self.is_instance_of_type(k, self.expected_key_type  )
+        #     self.is_instance_of_type(v, self.expected_value_type)
 
     def __setitem__(self, key, value):                                  # Check type-safety before allowing assignment.
         self.is_instance_of_type(key, self.expected_key_type)
         self.is_instance_of_type(value, self.expected_value_type)
         super().__setitem__(key, value)
 
-    def __repr__(self):
-        key_type_name   = type_str(self.expected_key_type)
-        value_type_name = type_str(self.expected_value_type)
-        return f"dict[{key_type_name}, {value_type_name}] with {len(self)} entries"
+    # def __repr__(self):
+    #     key_type_name   = type_str(self.expected_key_type)
+    #     value_type_name = type_str(self.expected_value_type)
+    #     return f"dict[{key_type_name}, {value_type_name}] with {len(self)} entries"
 
     def json(self):                                                                         # Convert the dictionary to a JSON-serializable format.
         from osbot_utils.type_safe.Type_Safe import Type_Safe                               # can only import this here to avoid circular imports

{osbot_utils-2.10.0 → osbot_utils-2.12.0}/osbot_utils/type_safe/methods/type_safe_property.py

@@ -2,7 +2,7 @@ from typing import TypeVar, Type, Optional
 
 T = TypeVar('T')
 
-def type_safe_property(target_path: str, target_name: str, expected_type: Optional[Type[T]] = None) -> property: # Creates a type-safe property that delegates get/set operations to a nested data object
+def type_safe_property(target_path: str, target_name: str, expected_type: Optional[Type[T]] = None) -> T: # Creates a type-safe property that delegates get/set operations to a nested data object
 
     def getter(self) -> T:
         target = self

osbot_utils-2.12.0/osbot_utils/type_safe/shared/Type_Safe__Annotations.py

@@ -0,0 +1,29 @@
+from osbot_utils.type_safe.shared.Type_Safe__Cache  import type_safe_cache
+
+
+class Type_Safe__Annotations:
+
+    def all_annotations(self, target):
+        return type_safe_cache.get_obj_annotations(target)                          # use cache
+
+    def all_annotations__in_class(self, cls):
+        return type_safe_cache.get_class_annotations(cls)
+
+    def obj_attribute_annotation(self, target, attr_name):
+        return self.all_annotations(target).get(attr_name)                          # use cache
+
+    def obj_is_attribute_annotation_of_type(self, target, attr_name, expected_type):
+        attribute_annotation = self.obj_attribute_annotation(target, attr_name)
+        if expected_type is attribute_annotation:
+            return True
+        if expected_type is type(attribute_annotation):
+            return True
+        if expected_type is type_safe_cache.get_origin(attribute_annotation):                         # handle genericAlias
+            return True
+        return False
+
+    def get_origin(self, var_type):
+        return type_safe_cache.get_origin(var_type)
+
+type_safe_annotations = Type_Safe__Annotations()
+