osbot-utils 2.73.0__py3-none-any.whl → 2.74.0__py3-none-any.whl

osbot_utils/type_safe/primitives/safe_str/cryptography/nacl/Safe_Str__NaCl__Public_Key.py

@@ -0,0 +1,28 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str                   import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Enum__Safe_Str__Regex_Mode import Enum__Safe_Str__Regex_Mode
+
+TYPE_SAFE_STR__NACL__PUBLIC_KEY__REGEX  = re.compile(r'^[a-fA-F0-9]{64}$')
+TYPE_SAFE_STR__NACL__PUBLIC_KEY__LENGTH = 64  # 32 bytes as hex = 64 characters
+
+# todo: refactor this with  Safe_Str__NaCl__Private_Key since the code is just about the same
+class Safe_Str__NaCl__Public_Key(Safe_Str):
+    """
+    Safe string class for NaCl (Curve25519) public keys in hexadecimal format.
+
+    NaCl public keys are 32 bytes (256 bits), represented as 64 hexadecimal characters.
+    These keys are used with libsodium/PyNaCl for asymmetric encryption using SealedBox.
+
+    Examples:
+    - "a1b2c3d4e5f6789012345678901234567890abcdefabcdefabcdefabcdefabcd"
+    - "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210"
+
+    Security Note: Public keys can be safely shared and transmitted.
+    """
+    regex             = TYPE_SAFE_STR__NACL__PUBLIC_KEY__REGEX
+    regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
+    max_length        = TYPE_SAFE_STR__NACL__PUBLIC_KEY__LENGTH
+    exact_length      = True
+    allow_empty       = False
+    trim_whitespace   = True
+    strict_validation = True

osbot_utils/type_safe/primitives/safe_str/cryptography/nacl/Schema__NaCl__Keys.py

@@ -0,0 +1,8 @@
+from osbot_utils.type_safe.Type_Safe                                                         import Type_Safe
+from osbot_utils.type_safe.primitives.safe_str.cryptography.nacl.Safe_Str__NaCl__Private_Key import Safe_Str__NaCl__Private_Key
+from osbot_utils.type_safe.primitives.safe_str.cryptography.nacl.Safe_Str__NaCl__Public_Key  import Safe_Str__NaCl__Public_Key
+
+
+class Schema__NaCl__Keys(Type_Safe):
+    public_key : Safe_Str__NaCl__Public_Key  = None
+    private_key: Safe_Str__NaCl__Private_Key = None

osbot_utils/{helpers/safe_str → type_safe/primitives/safe_str/filesystem}/Safe_Str__File__Name.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 TYPE_SAFE_STR__FILE__NAME__REGEX = re.compile(r'[^a-zA-Z0-9_\-. ]')
 

osbot_utils/{helpers/safe_str → type_safe/primitives/safe_str/filesystem}/Safe_Str__File__Path.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 TYPE_SAFE_STR__FILE_PATH__REGEX      = re.compile(r'[^a-zA-Z0-9_\-./\\ ]')  # Allow alphanumerics, underscores, hyphens, dots, slashes, and spaces
 TYPE_SAFE_STR__FILE_PATH__MAX_LENGTH = 1024

osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Git__Branch.py

@@ -0,0 +1,27 @@
+from osbot_utils.type_safe.primitives.safe_str.git.Safe_Str__Git__Ref_Base import Safe_Str__Git__Ref_Base
+
+
+class Safe_Str__Git__Branch(Safe_Str__Git__Ref_Base):
+    """
+    Safe string class for GitHub branch names.
+
+    Follows git-check-ref-format rules with additional branch-specific restrictions:
+    - Cannot start with a dash '-' (branch-specific rule)
+
+    Examples:
+    - "main", "master", "develop"
+    - "feature/oauth-login"
+    - "bugfix/issue-123"
+    - "release/v2.0"
+    """
+
+    def __new__(cls, value=None):
+        result = super().__new__(cls, value)
+
+        if result:
+            # Additional branch-specific rule: cannot start with dash
+            # (from git check-ref-format --branch documentation)
+            if result.startswith('-'):
+                raise ValueError(f"Branch name cannot start with dash: {result}")
+
+        return result

osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Git__Ref.py

@@ -0,0 +1,63 @@
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str                                  import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.cryptography.hashes.Safe_Str__SHA1        import Safe_Str__SHA1
+from osbot_utils.type_safe.primitives.safe_str.cryptography.hashes.Safe_Str__SHA1__Short import Safe_Str__SHA1__Short
+from osbot_utils.type_safe.primitives.safe_str.git.Safe_Str__Git__Branch                 import Safe_Str__Git__Branch
+from osbot_utils.type_safe.primitives.safe_str.git.Safe_Str__Git__Tag                    import Safe_Str__Git__Tag
+
+
+class Safe_Str__Git__Ref(Safe_Str):
+    """
+    Safe string class for any valid Git reference (branch, tag, or commit SHA).
+
+    This class validates that a string is a syntactically valid Git reference
+    without attempting to classify what type of reference it is.
+
+    A value is accepted if it passes validation as ANY of:
+    - A 40-character SHA (Safe_Str__SHA1)
+    - A 7-character short SHA (Safe_Str__SHA1__Short)
+    - A valid Git branch name (Safe_Str__Git__Branch)
+    - A valid Git tag name (Safe_Str__Git__Tag)
+
+    Used in GitHub API calls like:
+    - /repos/{owner}/{repo}/zipball/{ref}
+    - /repos/{owner}/{repo}/git/ref/{ref}
+    - /repos/{owner}/{repo}/commits/{ref}
+    """
+    max_length      = 255
+    allow_empty     = False
+    trim_whitespace = True
+
+    def __new__(cls, value=None):
+        # First, do basic Safe_Str processing
+        if value is None:
+            if cls.allow_empty:
+                value = ""
+            else:
+                raise ValueError(f"in {cls.__name__}, value cannot be None when allow_empty is False")
+
+        if not isinstance(value, str):
+            value = str(value)
+
+        if cls.trim_whitespace:
+            value = value.strip()
+
+        if not cls.allow_empty and (value is None or value == ""):
+            raise ValueError("Value cannot be empty when allow_empty is False")
+
+        if len(value) > cls.max_length:
+            raise ValueError(f"Value exceeds maximum length of {cls.max_length} characters (was {len(value)})")
+
+
+        validators = [('SHA'      , Safe_Str__SHA1        ),     # we will try to validate as different ref types
+                      ('short SHA', Safe_Str__SHA1__Short ),     # If ANY of these validation succeeds, accept the value
+                      ('branch'   , Safe_Str__Git__Branch ),
+                      ('tag'      , Safe_Str__Git__Tag    )]
+
+        for validator_name, validator_class in validators:
+            try:
+                sanitized_value = validator_class(value)                                            # Validation succeeded - use the sanitized value
+                return str.__new__(cls, sanitized_value)                                            # return since it is a valid ref
+            except ValueError:
+                continue                                                                            # This validator didn't accept it, try the next one
+
+        raise ValueError(f"Invalid Git ref: '{value}' is not a valid SHA, branch, or tag name")     # None of the validators accepted it - it's not a valid ref

osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Git__Ref_Base.py

@@ -0,0 +1,73 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+
+TYPE_SAFE_STR__GIT_REF__REGEX      = re.compile(r'[\x00-\x1f\x7f ~^:?*\[\]\\]')
+TYPE_SAFE_STR__GIT_REF__MAX_LENGTH = 255
+
+class Safe_Str__Git__Ref_Base(Safe_Str):
+    """
+    Base class for Git references following git-check-ref-format rules.
+
+    Git reference rules (from git-check-ref-format https://git-scm.com/docs/git-check-ref-format):
+    1. Can include slash `/` for hierarchical grouping, but no slash-separated
+       component can begin with a dot `.` or end with `.lock`
+    2. Cannot have two consecutive dots `..` anywhere
+    3. Cannot have ASCII control characters, space, tilde `~`, caret `^`,
+       colon `:`, question-mark `?`, asterisk `*`, or open bracket `[`
+    4. Cannot begin or end with a slash `/` or contain multiple consecutive slashes
+    5. Cannot end with a dot `.`
+    6. Cannot contain a sequence `@{`
+    7. Cannot be the single character `@`
+    8. Cannot contain a backslash `\`
+    """
+    regex                      = TYPE_SAFE_STR__GIT_REF__REGEX
+    max_length                 = TYPE_SAFE_STR__GIT_REF__MAX_LENGTH
+    allow_empty                = False
+    trim_whitespace            = True
+    allow_all_replacement_char = True
+
+    def __new__(cls, value=None):
+        result = super().__new__(cls, value)
+
+        if result:
+            # Rule: Cannot be the single character '@'
+            if result == '@':
+                raise ValueError(f"Reference cannot be the single character '@': {result}")
+
+            # Rule: Cannot have two consecutive dots '..'
+            if '..' in result:
+                raise ValueError(f"Reference cannot contain consecutive dots '..': {result}")
+
+            # Rule: Cannot contain sequence '@{'
+            if '@{' in result:
+                raise ValueError(f"Reference cannot contain '@{{': {result}")
+
+            # Rule: Cannot begin or end with a slash
+            if result.startswith('/') or result.endswith('/'):
+                raise ValueError(f"Reference cannot start or end with slash: {result}")
+
+            # Rule: Cannot contain multiple consecutive slashes
+            if '//' in result:
+                raise ValueError(f"Reference cannot contain consecutive slashes: {result}")
+
+            # Rule: Cannot end with a dot
+            if result.endswith('.'):
+                raise ValueError(f"Reference cannot end with dot: {result}")
+
+            # Rule: No slash-separated component can begin with '.' or end with '.lock'
+            if '/' in result:
+                components = result.split('/')
+                for component in components:
+                    if component.startswith('.'):
+                        raise ValueError(f"Path component cannot start with dot: {component}")
+                    if component.endswith('.lock'):
+                        raise ValueError(f"Path component cannot end with '.lock': {component}")
+            else:
+                # Single component (no slashes)
+                if result.startswith('.'):
+                    raise ValueError(f"Reference cannot start with dot: {result}")
+                if result.endswith('.lock'):
+                    raise ValueError(f"Reference cannot end with '.lock': {result}")
+
+        return result

osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Git__Tag.py

@@ -0,0 +1,17 @@
+from osbot_utils.type_safe.primitives.safe_str.git.Safe_Str__Git__Ref_Base import Safe_Str__Git__Ref_Base
+
+class Safe_Str__Git__Tag(Safe_Str__Git__Ref_Base):
+    """
+    Safe string class for GitHub tag names.
+
+    Follows git-check-ref-format rules for tags.
+    Tags have the same rules as general Git references.
+
+    Examples:
+    - "v1.0.0", "v2.3.4"
+    - "release-1.0.0"
+    - "2024.01.15"
+    - "stable", "latest"
+    """
+    pass
+

osbot_utils/{helpers/safe_str → type_safe/primitives/safe_str/git}/Safe_Str__Version.py

@@ -1,6 +1,6 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str                           import Safe_Str
-from osbot_utils.helpers.safe_str.schemas.Enum__Safe_Str__Regex_Mode import Enum__Safe_Str__Regex_Mode
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str                   import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Enum__Safe_Str__Regex_Mode import Enum__Safe_Str__Regex_Mode
 
 TYPE_SAFE_STR__VERSION__REGEX      = re.compile(r'^v(\d{1,3})\.(\d{1,3})\.(\d{1,3})$')              # Regex to match versions like v0.1.1 or v999.999.999
 TYPE_SAFE_STR__VERSION__MAX_LENGTH = 12                                                             # Max length for 'v999.999.999'

osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo.py

@@ -0,0 +1,46 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str                            import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.github.Safe_Str__GitHub__Repo_Name  import Safe_Str__GitHub__Repo_Name
+from osbot_utils.type_safe.primitives.safe_str.github.Safe_Str__GitHub__Repo_Owner import Safe_Str__GitHub__Repo_Owner
+
+TYPE_SAFE_STR__GITHUB__REPO__REGEX      = re.compile(r'[^a-zA-Z0-9\-_./]')
+TYPE_SAFE_STR__GITHUB__REPO__MAX_LENGTH = 140  # 39 (owner) + 1 (/) + 100 (repo)
+
+class Safe_Str__GitHub__Repo(Safe_Str):
+    """
+    Safe string class for full GitHub repository identifiers in owner/repo format.
+    
+    Examples:
+    - "octocat/Hello-World"
+    - "microsoft/vscode"
+    - "owasp-sbot/OSBot-Utils"
+    
+    This class leverages Safe_Str__GitHub__Repo_Owner and Safe_Str__GitHub__Repo_Name
+    for validation of the individual components.
+    """
+    regex                      = TYPE_SAFE_STR__GITHUB__REPO__REGEX
+    max_length                 = TYPE_SAFE_STR__GITHUB__REPO__MAX_LENGTH
+    allow_empty                = False
+    trim_whitespace            = True
+    allow_all_replacement_char = False
+    repo_owner                 : Safe_Str__GitHub__Repo_Owner = None                                 # note: due to the str override these will not show in the Pycharm code hints (but they will work)
+    repo_name                  : Safe_Str__GitHub__Repo_Name  = None
+
+    def __new__(cls, value=None):
+        result = super().__new__(cls, value)
+        
+        if result:
+            if '/' not in result:                                                                   # Check for the required forward slash
+                raise ValueError(f"GitHub repository must be in 'owner/repo' format: {result}")
+            
+
+            parts = result.split('/')                                                               # Split and validate components using the dedicated classes
+            if len(parts) != 2:
+                raise ValueError(f"GitHub repository must be in 'owner/repo' format: {result}")
+            
+            owner_part, repo_part = parts
+
+            result.repo_owner = Safe_Str__GitHub__Repo_Owner(owner_part)                            # Validate using the dedicated classes (and store the references)
+            result.repo_name  = Safe_Str__GitHub__Repo_Name(repo_part  )                            # This will raise appropriate errors if validation fails
+        
+        return result

osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo_Name.py

@@ -0,0 +1,35 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+TYPE_SAFE_STR__GITHUB__REPO_NAME__REGEX      = re.compile(r'[^a-zA-Z0-9\-_.]')
+TYPE_SAFE_STR__GITHUB__REPO_NAME__MAX_LENGTH = 100
+
+class Safe_Str__GitHub__Repo_Name(Safe_Str):
+    """
+    Safe string class for GitHub repository names.
+
+    GitHub repository name rules:
+    - May contain alphanumeric characters, hyphens, underscores, and periods
+    - Maximum length of 100 characters
+    - Cannot be empty
+    """
+    regex                      = TYPE_SAFE_STR__GITHUB__REPO_NAME__REGEX
+    max_length                 = TYPE_SAFE_STR__GITHUB__REPO_NAME__MAX_LENGTH
+    allow_empty                = False
+    trim_whitespace            = True
+    allow_all_replacement_char = False
+
+    def __new__(cls, value=None):
+        result = super().__new__(cls, value)
+
+        # Additional validation
+        if result:
+            # Check if it's just periods (reserved names)
+            if result in ['.', '..']:
+                raise ValueError(f"Invalid repository name: {result}")
+
+            # Check for all replacement characters
+            if set(result) == {'_'} and len(result) > 0:
+                raise ValueError(f"Invalid repository name: {result}")
+
+        return result

osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo_Owner.py

@@ -0,0 +1,39 @@
+import re
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
+
+TYPE_SAFE_STR__GITHUB__REPO_OWNER__REGEX = re.compile(r'[^a-zA-Z0-9\-]')
+TYPE_SAFE_STR__GITHUB__REPO_OWNER__MAX_LENGTH = 39
+
+class Safe_Str__GitHub__Repo_Owner(Safe_Str):
+    """
+    Safe string class for GitHub repository owners (users or organizations).
+
+    GitHub username/organization rules:
+    - May only contain alphanumeric characters or hyphens
+    - Cannot have multiple consecutive hyphens
+    - Cannot begin or end with a hyphen
+    - Maximum length of 39 characters
+    """
+    regex                      = TYPE_SAFE_STR__GITHUB__REPO_OWNER__REGEX
+    max_length                 = TYPE_SAFE_STR__GITHUB__REPO_OWNER__MAX_LENGTH
+    allow_empty                = False
+    trim_whitespace            = True
+    allow_all_replacement_char = False
+
+    def __new__(cls, value=None):
+        result = super().__new__(cls, value)
+
+
+        if result:                                                                                  # Additional GitHub-specific validation
+            if result.startswith('-') or result.endswith('-'):                                      # Check for leading/trailing hyphens
+                raise ValueError(f"GitHub owner name cannot start or end with a hyphen: {result}")
+
+            if '--' in result:                                                                      # Check for consecutive hyphens
+                raise ValueError(f"GitHub owner name cannot contain consecutive hyphens: {result}")
+
+            if result.replace('_', '') == '':                                                       # Check for all underscores (sanitized invalid input)
+                raise ValueError(f"Invalid GitHub owner name: {result}")
+
+        return result
+
+

osbot_utils/{helpers → type_safe/primitives}/safe_str/http/Safe_Str__Http__Content_Type.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 TYPE_SAFE_STR__HTTP__CONTENT_TYPE__REGEX = re.compile(r'[^a-zA-Z0-9/\-+.;= ]')
 TYPE_SAFE_STR__HTTP__CONTENT_TYPE__MAX_LENGTH = 256

osbot_utils/{helpers → type_safe/primitives}/safe_str/http/Safe_Str__Http__ETag.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 TYPE_SAFE_STR__HTTP__ETAG__REGEX = re.compile(r'[^a-zA-Z0-9"\/\-_.:]')  # Allow alphanumerics, quotes, slashes, hyphens, underscores, periods, colons
 TYPE_SAFE_STR__HTTP__ETAG__MAX_LENGTH = 128

osbot_utils/{helpers → type_safe/primitives}/safe_str/http/Safe_Str__Http__Last_Modified.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 TYPE_SAFE_STR__HTTP__LAST_MODIFIED__REGEX = re.compile(r'[^a-zA-Z0-9:, -]')
 TYPE_SAFE_STR__HTTP__LAST_MODIFIED__MAX_LENGTH = 64

osbot_utils/{helpers → type_safe/primitives}/safe_str/http/Safe_Str__Http__Text.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 
 TYPE_SAFE_STR__TEXT__MAX_LENGTH = 1048576           # Define the size constant - 1 megabyte in bytes

osbot_utils/{helpers → type_safe/primitives/safe_str/identifiers}/Guid.py

@@ -1,9 +1,10 @@
 import uuid
-from osbot_utils.utils.Misc import is_guid
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+from osbot_utils.utils.Misc                     import is_guid
 
 GUID__NAMESPACE = uuid.UUID('2cfec064-537a-4ff7-8fdc-2fc9e2606f3d')
 
-class Guid(str):
+class Guid(Type_Safe__Primitive, str):
     def __new__(cls, value: str):
         if not isinstance(value, str):                                                  # Check if the value is a string
             raise ValueError(f'in Guid: value provided was not a string: {value}')      # if not raise a ValueError

osbot_utils/{helpers/safe_str → type_safe/primitives/safe_str/text}/Safe_Str__Text.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 TYPE_SAFE_STR__TEXT__MAX_LENGTH = 4096
 TYPE_SAFE_STR__TEXT__REGEX      = r'[^a-zA-Z0-9_ ()\[\]\-+=:;,.?]'

osbot_utils/{helpers/safe_str → type_safe/primitives/safe_str/text}/Safe_Str__Text__Dangerous.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 TYPE_SAFE_STR__TEXT__DANGEROUS__MAX_LENGTH = 65536
 TYPE_SAFE_STR__TEXT__DANGEROUS__REGEX      = r'[^a-zA-Z0-9_\s!@#$%^&*()\[\]{}\-+=:;,.?"/\\<>\']'

osbot_utils/{helpers/safe_str/http → type_safe/primitives/safe_str/web}/Safe_Str__Html.py

@@ -1,5 +1,5 @@
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 # Define the size constant
 TYPE_SAFE_STR__HTML__MAX_LENGTH = 1048576  # 1 megabyte in bytes

osbot_utils/{helpers/safe_str → type_safe/primitives/safe_str/web}/Safe_Str__Url.py

@@ -1,6 +1,6 @@
 
 import re
-from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+from osbot_utils.type_safe.primitives.safe_str.Safe_Str import Safe_Str
 
 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

osbot_utils/{helpers/safe_int → type_safe/primitives/safe_uint}/Safe_UInt.py

@@ -1,4 +1,5 @@
-from osbot_utils.helpers.safe_int.Safe_Int import Safe_Int
+from osbot_utils.type_safe.primitives.safe_int.Safe_Int import Safe_Int
+
 
 class Safe_UInt(Safe_Int):             # Unsigned Integer - only accepts non-negative integer values
 

osbot_utils/{helpers/safe_int → type_safe/primitives/safe_uint}/Safe_UInt__Byte.py

@@ -1,4 +1,4 @@
-from osbot_utils.helpers.safe_int.Safe_UInt import Safe_UInt
+from osbot_utils.type_safe.primitives.safe_uint.Safe_UInt import Safe_UInt
 
 TYPE_SAFE_UINT__BYTE__MIN_VALUE = 0
 TYPE_SAFE_UINT__BYTE__MAX_VALUE = 255

osbot_utils/{helpers/safe_int → type_safe/primitives/safe_uint}/Safe_UInt__FileSize.py

@@ -1,4 +1,4 @@
-from osbot_utils.helpers.safe_int.Safe_UInt import Safe_UInt
+from osbot_utils.type_safe.primitives.safe_uint.Safe_UInt import Safe_UInt
 
 TYPE_SAFE_UINT__FILE_SIZE__MIN_VALUE = 0
 TYPE_SAFE_UINT__FILE_SIZE__MAX_VALUE = 2 ** 63 - 1         # Max file size on most systems

osbot_utils/{helpers/safe_int → type_safe/primitives/safe_uint}/Safe_UInt__Percentage.py

@@ -1,4 +1,4 @@
-from osbot_utils.helpers.safe_int.Safe_UInt import Safe_UInt
+from osbot_utils.type_safe.primitives.safe_uint.Safe_UInt import Safe_UInt
 
 TYPE_SAFE_UINT__PERCENTAGE__MIN_VALUE = 0
 TYPE_SAFE_UINT__PERCENTAGE__MAX_VALUE = 100

osbot_utils/{helpers/safe_int → type_safe/primitives/safe_uint}/Safe_UInt__Port.py

@@ -1,4 +1,4 @@
-from osbot_utils.helpers.safe_int.Safe_UInt import Safe_UInt
+from osbot_utils.type_safe.primitives.safe_uint.Safe_UInt import Safe_UInt
 
 TYPE_SAFE_UINT__PORT__MIN_VALUE = 0
 TYPE_SAFE_UINT__PORT__MAX_VALUE = 65535

osbot_utils/type_safe/{Type_Safe__Dict.py → type_safe_core/collections/Type_Safe__Dict.py}

@@ -1,6 +1,7 @@
-from typing                                import Type
-from osbot_utils.type_safe.Type_Safe__List import Type_Safe__List
-from osbot_utils.type_safe.Type_Safe__Base import Type_Safe__Base
+from typing                                                           import Type
+from osbot_utils.type_safe.Type_Safe__Base                            import Type_Safe__Base
+from osbot_utils.type_safe.type_safe_core.collections.Type_Safe__List import Type_Safe__List
+
 
 class Type_Safe__Dict(Type_Safe__Base, dict):
     def __init__(self, expected_key_type, expected_value_type, *args, **kwargs):

osbot_utils/type_safe/{decorators → type_safe_core/decorators}/type_safe.py

@@ -1,5 +1,6 @@
 import functools                                                                           # For wrapping functions
-from osbot_utils.type_safe.Type_Safe__Method import Type_Safe__Method
+from osbot_utils.type_safe.type_safe_core.methods.Type_Safe__Method import Type_Safe__Method
+
 
 def type_safe(func):                                                                        # Main decorator function
     type_checker = Type_Safe__Method(func)  # Create type checker instance

osbot_utils/type_safe/{Type_Safe__Method.py → type_safe_core/methods/Type_Safe__Method.py}

@@ -1,8 +1,7 @@
-import inspect                                                                            # For function introspection
-from enum       import Enum
-from typing     import get_args, get_origin, Union, List, Any, Dict                     # For type hinting utilities
-
-from osbot_utils.type_safe.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
+import inspect                                                                                                                       # For function introspection
+from enum                                                                     import Enum
+from typing                                                                   import get_args, get_origin, Union, List, Any, Dict    # For type hinting utilities
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
 
 
 class Type_Safe__Method:                                                                  # Class to handle method type safety validation

osbot_utils/type_safe/{shared → type_safe_core/shared}/Type_Safe__Annotations.py

@@ -1,4 +1,4 @@
-from osbot_utils.type_safe.shared.Type_Safe__Cache  import type_safe_cache
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache import type_safe_cache
 
 
 class Type_Safe__Annotations:

osbot_utils/type_safe/{shared → type_safe_core/shared}/Type_Safe__Cache.py

@@ -1,7 +1,7 @@
 import inspect
-from weakref                                                    import WeakKeyDictionary
-from osbot_utils.type_safe.shared.Type_Safe__Not_Cached         import type_safe_not_cached
-from osbot_utils.type_safe.shared.Type_Safe__Shared__Variables  import IMMUTABLE_TYPES
+from weakref                                                                  import WeakKeyDictionary
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Not_Cached        import type_safe_not_cached
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
 
 
 class Type_Safe__Cache:

osbot_utils/type_safe/{shared → type_safe_core/shared}/Type_Safe__Convert.py

@@ -1,6 +1,6 @@
-from typing                                         import get_args
-from osbot_utils.type_safe.shared.Type_Safe__Cache  import type_safe_cache
-from osbot_utils.utils.Objects                      import base_classes_names
+from typing                                                       import get_args
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache import type_safe_cache
+from osbot_utils.utils.Objects                                    import base_classes_names
 
 
 class Type_Safe__Convert:

osbot_utils/type_safe/{shared → type_safe_core/shared}/Type_Safe__Json_Compressor.py

@@ -1,9 +1,9 @@
-from typing                                                                 import Dict, Any, Type
-from osbot_utils.type_safe.Type_Safe__Base                                  import Type_Safe__Base
-from osbot_utils.type_safe.Type_Safe                                        import Type_Safe
-from osbot_utils.type_safe.shared.Type_Safe__Cache                          import type_safe_cache
-from osbot_utils.type_safe.shared.Type_Safe__Json_Compressor__Type_Registry import Type_Safe__Json_Compressor__Type_Registry
-from osbot_utils.utils.Objects                                              import class_full_name
+from typing                                                                                 import Dict, Any, Type
+from osbot_utils.type_safe.Type_Safe__Base                                                  import Type_Safe__Base
+from osbot_utils.type_safe.Type_Safe                                                        import Type_Safe
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache                           import type_safe_cache
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Json_Compressor__Type_Registry  import Type_Safe__Json_Compressor__Type_Registry
+from osbot_utils.utils.Objects                                                              import class_full_name
 
 class Type_Safe__Json_Compressor(Type_Safe__Base):
 

osbot_utils/type_safe/{shared → type_safe_core/shared}/Type_Safe__Raise_Exception.py

@@ -1,4 +1,4 @@
-from osbot_utils.type_safe.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
 
 
 class Type_Safe__Raise_Exception:

osbot_utils/type_safe/{shared → type_safe_core/shared}/Type_Safe__Validation.py

@@ -2,13 +2,14 @@ import collections
 import inspect
 import types
 import typing
-from enum                                                      import EnumMeta
-from typing                                                    import Any, Annotated, Optional, get_args, get_origin, ForwardRef, Type, Dict, _GenericAlias
-from osbot_utils.type_safe.Type_Safe__Primitive                import Type_Safe__Primitive
-from osbot_utils.type_safe.shared.Type_Safe__Annotations       import type_safe_annotations
-from osbot_utils.type_safe.shared.Type_Safe__Cache             import type_safe_cache
-from osbot_utils.type_safe.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
-from osbot_utils.type_safe.shared.Type_Safe__Raise_Exception   import type_safe_raise_exception
+from enum                                                                     import EnumMeta
+from typing                                                                   import Any, Annotated, Optional, get_args, get_origin, ForwardRef, Type, Dict, _GenericAlias
+from osbot_utils.type_safe.Type_Safe__Primitive                               import Type_Safe__Primitive
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Annotations       import type_safe_annotations
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Cache             import type_safe_cache
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Raise_Exception   import type_safe_raise_exception
+from osbot_utils.type_safe.type_safe_core.shared.Type_Safe__Shared__Variables import IMMUTABLE_TYPES
+
 
 class Type_Safe__Validation: