refactored into this project the Cache__Hash__Generator which is a very useful class to have here

    that class needs the (also added) : Schema__Cache__Hash__Config , Enum__Hash__Algorithm and Safe_Str__Json__Field_Path
improved the Safe_Str__Url class
added new helpers for: Safe_Str__Url__Path, Safe_Str__Url__Path_Query, Safe_Str__Url__Query,  Safe_Str__Url__Server and Safe_Str__Domain
added comprehensive tests for all of the above

Author: DinisCruz

osbot_utils/helpers/cache/Cache__Hash__Generator.py

@@ -0,0 +1,70 @@
+import hashlib
+import json
+from typing                                                                                   import List
+from osbot_utils.helpers.cache.schemas.Schema__Cache__Hash__Config                            import Schema__Cache__Hash__Config
+from osbot_utils.type_safe.Type_Safe                                                          import Type_Safe
+from osbot_utils.type_safe.primitives.domains.cryptography.enums.Enum__Hash__Algorithm        import Enum__Hash__Algorithm
+from osbot_utils.type_safe.primitives.domains.cryptography.safe_str.Safe_Str__Cache_Hash      import Safe_Str__Cache_Hash
+from osbot_utils.type_safe.primitives.domains.identifiers.safe_str.Safe_Str__Json__Field_Path import Safe_Str__Json__Field_Path
+
+
+class Cache__Hash__Generator(Type_Safe):                                           # Generate consistent hashes from various input types
+    config: Schema__Cache__Hash__Config
+
+    def calculate(self, data: bytes) -> Safe_Str__Cache_Hash:                      # Calculate hash from raw bytes
+        if self.config.algorithm == Enum__Hash__Algorithm.MD5:
+            hash_full = hashlib.md5(data).hexdigest()
+        elif self.config.algorithm == Enum__Hash__Algorithm.SHA256:
+            hash_full = hashlib.sha256(data).hexdigest()
+        elif self.config.algorithm == Enum__Hash__Algorithm.SHA384:
+            hash_full = hashlib.sha384(data).hexdigest()
+
+        return Safe_Str__Cache_Hash(hash_full[:self.config.length])
+
+    def from_string(self, data: str) -> Safe_Str__Cache_Hash:                       # Hash from string
+        return self.calculate(data.encode('utf-8'))
+
+    def from_bytes(self, data: bytes) -> Safe_Str__Cache_Hash:                      # Hash from bytes
+        return self.calculate(data)
+
+    def from_json(self, data      : dict     ,                                      # Hash JSON with optional field exclusion
+                        exclude_fields: List[str] = None
+                   ) -> Safe_Str__Cache_Hash:
+        if exclude_fields:
+            data = {k: v for k, v in data.items() if k not in exclude_fields}
+        json_str = json.dumps(data, sort_keys=True)
+        return self.from_string(json_str)
+
+    def from_type_safe(self, obj           : Type_Safe     ,                      # Hash Type_Safe object
+                             exclude_fields : List[str] = None
+                        ) -> Safe_Str__Cache_Hash:
+        return self.from_json(obj.json(), exclude_fields)
+
+    def from_json_field(self, data      : dict,
+                              json_field: Safe_Str__Json__Field_Path
+                         ) -> Safe_Str__Cache_Hash:
+
+        field_value = self.extract_field_value(data, json_field)                                                                    # Extract field value using dot notation
+
+        if field_value is None:
+            raise ValueError(f"Field '{json_field}' not found in data")
+
+        if   isinstance(field_value, str):                      return self.from_string(           field_value )                    # Convert field value to string representation
+        elif isinstance(field_value, (int, float, bool)):       return self.from_string(str       (field_value))
+        elif isinstance(field_value, dict):                     return self.from_json  (           field_value )
+        elif isinstance(field_value, list):                     return self.from_string(json.dumps(field_value, sort_keys=True))    # Hash the JSON representation of the list
+        else:
+            raise ValueError(f"Unsupported field type: {type(field_value)}")
+
+    def extract_field_value(self, data: dict, json_field: Safe_Str__Json__Field_Path):
+        parts  = json_field.split('.')
+        current = data
+
+        for part in parts:
+            if not isinstance(current, dict):
+                return None
+            current = current.get(part)
+            if current is None:
+                return None
+
+        return current

osbot_utils/helpers/cache/__init__.py

@@ -0,0 +1,7 @@
+from osbot_utils.type_safe.Type_Safe                                                   import Type_Safe
+from osbot_utils.type_safe.primitives.domains.cryptography.enums.Enum__Hash__Algorithm import Enum__Hash__Algorithm
+
+
+class Schema__Cache__Hash__Config(Type_Safe):                                      # Configuration for hash generation
+    algorithm : Enum__Hash__Algorithm = Enum__Hash__Algorithm.SHA256               # Hash algorithm to use
+    length    : int                   = 16                                         # Hash length: 10, 16, 32, 64, 96

osbot_utils/helpers/cache/schemas/Schema__Cache__Hash__Config.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class Enum__Hash__Algorithm(Enum):
+    MD5    = "md5"
+    SHA256 = "sha256"
+    SHA384 = "sha384"

osbot_utils/helpers/cache/schemas/__init__.py

@@ -0,0 +1,25 @@
+import re
+from osbot_utils.type_safe.primitives.core.Safe_Str import Safe_Str
+
+TYPE_SAFE_STR__FIELD_PATH__REGEX      = re.compile(r'[^a-zA-Z0-9_\-.]')  # Allow dots for nesting
+TYPE_SAFE_STR__FIELD_PATH__MAX_LENGTH = 256                              # Longer to support deep nesting
+
+class Safe_Str__Json__Field_Path(Safe_Str):
+    regex           = TYPE_SAFE_STR__FIELD_PATH__REGEX
+    max_length      = TYPE_SAFE_STR__FIELD_PATH__MAX_LENGTH
+    trim_whitespace = True
+
+    def __new__(cls, value: str = None):
+        if value:
+            if '..' in value:                                                                       # Don't allow consecutive dots
+                raise ValueError(f"Field path cannot contain consecutive dots: '{value}'")
+
+            if value.startswith('.') or value.endswith('.'):                                        # Don't allow leading/trailing dots
+                raise ValueError(f"Field path cannot start or end with a dot: '{value}'")
+
+            segments = value.split('.')                                                             # Each segment should be non-empty after splitting
+            for segment in segments:
+                if not segment:
+                    raise ValueError(f"Field path has empty segment: '{value}'")
+
+        return Safe_Str.__new__(cls, value)

osbot_utils/type_safe/primitives/domains/cryptography/enums/Enum__Hash__Algorithm.py

@@ -0,0 +1,98 @@
+import re
+from osbot_utils.type_safe.primitives.core.Safe_Str                         import Safe_Str
+from osbot_utils.type_safe.primitives.core.enums.Enum__Safe_Str__Regex_Mode import Enum__Safe_Str__Regex_Mode
+
+TYPE_SAFE_STR__DOMAIN__MAX_LENGTH = 253  # RFC 1035 max domain length
+TYPE_SAFE_STR__DOMAIN__REGEX      = re.compile(r'^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)*$')
+
+class Safe_Str__Domain(Safe_Str):
+    """
+    Safe string class for domain names (without scheme or port).
+
+    Validates according to RFC 1035 and RFC 1123:
+    - Each label max 63 characters
+    - Total max 253 characters
+    - Labels: alphanumeric + hyphens (not at start/end)
+    - At least one dot (except 'localhost')
+
+    Examples:
+    - "example.com"
+    - "api.example.com"
+    - "sub.domain.example.com"
+    - "localhost"
+    - "my-site.co.uk"
+
+    Not valid:
+    - "https://example.com" (use Safe_Str__Url__Server)
+    - "192.168.1.1" (use Safe_Str__IP_Address)
+    - "example.com:8080" (use Safe_Str__Url__Server)
+    """
+    regex             = TYPE_SAFE_STR__DOMAIN__REGEX
+    regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
+    max_length        = TYPE_SAFE_STR__DOMAIN__MAX_LENGTH
+    trim_whitespace   = True
+    strict_validation = True
+    allow_empty       = True
+
+    def __new__(cls, value=None):
+        if value is None or value == '':
+            return super().__new__(cls, value)
+
+        # Basic regex validation via parent
+        instance = super().__new__(cls, value)
+
+        # Additional validation
+        cls._validate_domain(str(instance))
+
+        return instance
+
+    @classmethod
+    def _validate_domain(cls, domain):
+        """Validate domain name structure"""
+        if not domain or domain == '':
+            return
+
+        # Special case: localhost
+        if domain == 'localhost':
+            return
+
+        # Must have at least one dot
+        if '.' not in domain:
+            raise ValueError(f"Invalid domain '{domain}': must contain at least one dot (or be 'localhost')")
+
+        # Split and validate each label
+        labels = domain.split('.')
+
+        for label in labels:
+            # Each label must be 1-63 characters
+            if not label or len(label) > 63:
+                raise ValueError(f"Invalid domain '{domain}': label '{label}' length must be 1-63 characters")
+
+            # Cannot start or end with hyphen
+            if label.startswith('-') or label.endswith('-'):
+                raise ValueError(f"Invalid domain '{domain}': label '{label}' cannot start or end with hyphen")
+
+            # Must be alphanumeric + hyphens
+            if not re.match(r'^[a-zA-Z0-9\-]+$', label):
+                raise ValueError(f"Invalid domain '{domain}': label '{label}' contains invalid characters")
+
+    def __add__(self, other):
+        """Enable composability with URL components"""
+        from osbot_utils.type_safe.primitives.domains.web.safe_str.Safe_Str__Url__Server import Safe_Str__Url__Server
+
+        # Domain + "https://" prefix = Server
+        if isinstance(other, str) and other.startswith('http'):
+            return Safe_Str__Url__Server(f"{other}{self}")
+
+        # Default string concatenation
+        return str(self) + str(other)
+
+    def __radd__(self, other):
+        """Reverse addition: scheme + domain = server"""
+        from osbot_utils.type_safe.primitives.domains.web.safe_str.Safe_Str__Url__Server import Safe_Str__Url__Server
+
+        if isinstance(other, str):
+            if other in ('https://', 'http://'):
+                return Safe_Str__Url__Server(f"{other}{self}")
+
+        return str(other) + str(self)

osbot_utils/type_safe/primitives/domains/cryptography/enums/__init__.py

@@ -1,11 +1,38 @@
 import re
-from osbot_utils.type_safe.primitives.core.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.core.Safe_Str                         import Safe_Str
+from osbot_utils.type_safe.primitives.core.enums.Enum__Safe_Str__Regex_Mode import Enum__Safe_Str__Regex_Mode
 
-TYPE_SAFE_STR__URL__MAX_LENGTH = 2048                                                        # Common maximum URL length
-TYPE_SAFE_STR__URL__REGEX      = re.compile(r'^(?!https?://).*|[^a-zA-Z0-9:/\-._~&=?#+%@]')  # Allow characters valid in URLs
+TYPE_SAFE_STR__URL__MAX_LENGTH = 8192   # Modern URL length limit (8192 characters)
+                                        # - Old IE11 limit was 2,083 (obsolete as of 2022)
+                                        # - Modern browsers support 64K+ characters
+                                        # - Common server defaults: Apache (8K), Nginx (4-8K)
+                                        # - CDN limits: Cloudflare (16K), AWS API Gateway (10K)
+                                        # - Handles OAuth/SAML redirects (typically 3-6K)
+                                        # - Handles marketing/analytics URLs (typically 2-4K)
+                                        # - Still protects against abuse (8K+ is suspicious)
+
+TYPE_SAFE_STR__URL__REGEX = re.compile(
+    r'^https?://'                           # Scheme
+    r'[a-zA-Z0-9.\-]+'                      # Domain/IP
+    r'(:[0-9]{1,5})?'                       # Optional port
+    r'(/[a-zA-Z0-9/\-._~%]*)?'              # Optional path
+    r'(\?[a-zA-Z0-9=&\-._~%+]*)?'           # Optional query
+    r'(#[a-zA-Z0-9\-._~%]*)?$'              # Optional fragment
+)
 
 class Safe_Str__Url(Safe_Str):
+    """
+    Safe string class for complete URLs.
+
+    Examples:
+    - "https://example.com"
+    - "http://localhost:8080/api/users?page=1"
+    - "https://api.example.com/v1/products/123?format=json"
+    """
     regex                      = TYPE_SAFE_STR__URL__REGEX
+    regex_mode                 = Enum__Safe_Str__Regex_Mode.MATCH
     max_length                 = TYPE_SAFE_STR__URL__MAX_LENGTH
     trim_whitespace            = True
+    strict_validation          = True
+    allow_empty                = True
     allow_all_replacement_char = False