osbot-utils 2.84.0__tar.gz → 2.85.0__tar.gz

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.84.0
+Version: 2.85.0
 Summary: OWASP Security Bot - Utils
 License: MIT
 Author: Dinis Cruz
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.84.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.85.0-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-2.84.0 → osbot_utils-2.85.0}/README.md

@@ -1,6 +1,6 @@
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.84.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.85.0-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-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/Safe_Str.py

@@ -12,7 +12,7 @@ class Safe_Str(Type_Safe__Primitive, str):
     regex                     : re.Pattern                 = TYPE_SAFE__STR__REGEX__SAFE_STR
     regex_mode                : Enum__Safe_Str__Regex_Mode = Enum__Safe_Str__Regex_Mode.REPLACE
     replacement_char          : str                        = '_'
-    allow_empty               : bool                       = True
+    allow_empty               : bool                       = True                # note: making this False does cause some side effects on .json() on cases like auto serialization in environments like FastAPI (like it requires more explict value setting), so all have now been converted into a value of True
     trim_whitespace           : bool                       = False
     allow_all_replacement_char: bool                       = True
     strict_validation         : bool                       = False               # If True, don't replace invalid chars, raise an error instead
@@ -34,12 +34,12 @@ class Safe_Str(Type_Safe__Primitive, str):
             value = value.strip()
 
         if not cls.allow_empty and (value is None or value == ""):                                                      # Check for empty string if not allowed
-            raise ValueError("Value cannot be empty when allow_empty is False")
+            raise ValueError(f"in {cls.__name__}, value cannot be empty when allow_empty is False")
 
-        if cls.exact_length and len(value) != cls.max_length:
-            raise ValueError(f"Value must be exactly {cls.max_length} characters long (was {len(value)})")
+        if cls.exact_length and len(value) and len(value) != cls.max_length:
+            raise ValueError(f"in {cls.__name__}, value must be exactly {cls.max_length} characters long (was {len(value)})")
         elif not cls.exact_length and len(value) > cls.max_length:                                                      # Check max length
-            raise ValueError(f"Value exceeds maximum length of {cls.max_length} characters (was {len(value)})")
+            raise ValueError(f"in {cls.__name__}, value exceeds maximum length of {cls.max_length} characters (was {len(value)})")
 
         if cls.allow_empty and value =='':
             return str.__new__(cls, '')
@@ -54,22 +54,22 @@ class Safe_Str(Type_Safe__Primitive, str):
         if cls.strict_validation:
             if cls.regex_mode == Enum__Safe_Str__Regex_Mode.MATCH:               # For 'match' mode, regex defines the valid pattern (like version numbers)
                 if not cls.regex.match(value):
-                    raise ValueError(f"Value does not match required pattern: {cls.regex.pattern}")
+                    raise ValueError(f"in {cls.__name__}, value does not match required pattern: {cls.regex.pattern}")
                 return value
             elif cls.regex_mode == Enum__Safe_Str__Regex_Mode.REPLACE:           # For 'replace' mode, regex defines invalid characters to replace
                 if cls.regex.search(value) is not None:
-                    raise ValueError(f"Value contains invalid characters (must not match pattern: {cls.regex.pattern})")
+                    raise ValueError(f"in {cls.__name__}, value contains invalid characters (must not match pattern: {cls.regex.pattern})")
                 return value
             else:
                 raise ValueError(f"in {cls.__name__}, regex_mode value cannot be None when strict_validation is True")
         else:
             if cls.regex_mode == Enum__Safe_Str__Regex_Mode.MATCH:               # Cannot do replacement when regex defines valid pattern
-                raise ValueError(f"Cannot use regex_mode='match' without strict_validation=True")
+                raise ValueError(f"in {cls.__name__}, cannot use regex_mode='match' without strict_validation=True")
             else:                                                                # assume the default Enum__Safe_Str__Regex_Mode.MATCH
                 sanitized_value =  cls.regex.sub(cls.replacement_char, value)
 
                 if not cls.allow_all_replacement_char and set(sanitized_value) == {
                     cls.replacement_char} and sanitized_value:
-                    raise ValueError(f"Sanitized value consists entirely of '{cls.replacement_char}' characters")
+                    raise ValueError(f"in {cls.__name__}, sanitized value consists entirely of '{cls.replacement_char}' characters")
 
                 return sanitized_value

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/hashes/Safe_Str__Hash.py

@@ -10,10 +10,10 @@ TYPE_SAFE_STR__HASH__REGEX = re.compile(r'[^a-fA-F0-9]')                # Only a
 class Safe_Str__Hash(Safe_Str):
     regex                     = TYPE_SAFE_STR__HASH__REGEX
     max_length                = SIZE__VALUE_HASH
-    allow_empty               = False                                   # Don't allow empty hash values
-    trim_whitespace           = True                                    # Trim any whitespace
-    strict_validation         = True                                    # Enable strict validation - new attribute
-    exact_length              = True                                    # Require exact length match - new attribute
+    allow_empty               = True                                   # Don't allow empty hash values
+    trim_whitespace           = True                                   # Trim any whitespace
+    strict_validation         = True                                   # Enable strict validation - new attribute
+    exact_length              = True                                   # Require exact length match - new attribute
 
 def safe_str_hash(value: Any) -> Safe_Str__Hash:
     if isinstance(value, str):

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/hashes/Safe_Str__SHA1.py

@@ -21,6 +21,6 @@ class Safe_Str__SHA1(Safe_Str):
     regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
     max_length        = TYPE_SAFE_STR__GITHUB__SHA__LENGTH
     exact_length      = True
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/hashes/Safe_Str__SHA1__Short.py

@@ -19,6 +19,6 @@ class Safe_Str__SHA1__Short(Safe_Str):
     regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
     max_length        = TYPE_SAFE_STR__GITHUB__SHA_SHORT__LENGTH
     exact_length      = True
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/nacl/Safe_Str__NaCl__Private_Key.py

@@ -22,6 +22,6 @@ class Safe_Str__NaCl__Private_Key(Safe_Str):
     regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
     max_length        = TYPE_SAFE_STR__NACL__PRIVATE_KEY__LENGTH
     exact_length      = True
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/cryptography/nacl/Safe_Str__NaCl__Public_Key.py

@@ -23,6 +23,6 @@ class Safe_Str__NaCl__Public_Key(Safe_Str):
     regex_mode        = Enum__Safe_Str__Regex_Mode.MATCH
     max_length        = TYPE_SAFE_STR__NACL__PUBLIC_KEY__LENGTH
     exact_length      = True
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/filesystem/Safe_Str__File__Name.py

@@ -5,6 +5,6 @@ TYPE_SAFE_STR__FILE__NAME__REGEX = re.compile(r'[^a-zA-Z0-9_\-. ]')
 
 class Safe_Str__File__Name(Safe_Str):
     regex                      = TYPE_SAFE_STR__FILE__NAME__REGEX
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Git__Ref.py

@@ -24,7 +24,7 @@ class Safe_Str__Git__Ref(Safe_Str):
     - /repos/{owner}/{repo}/commits/{ref}
     """
     max_length      = 255
-    allow_empty     = False
+    allow_empty     = True
     trim_whitespace = True
 
     def __new__(cls, value=None):

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Git__Ref_Base.py

@@ -23,7 +23,7 @@ class Safe_Str__Git__Ref_Base(Safe_Str):
     """
     regex                      = TYPE_SAFE_STR__GIT_REF__REGEX
     max_length                 = TYPE_SAFE_STR__GIT_REF__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = True
 

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/git/Safe_Str__Version.py

@@ -9,7 +9,7 @@ class Safe_Str__Version(Safe_Str):
     regex             = TYPE_SAFE_STR__VERSION__REGEX
     regex_mode        =  Enum__Safe_Str__Regex_Mode.MATCH                                            # in this case we need an exact match of the version regex
     max_length        = TYPE_SAFE_STR__VERSION__MAX_LENGTH
-    allow_empty       = False
+    allow_empty       = True
     trim_whitespace   = True
     strict_validation = True                                                                        # Ensure the value exactly matches the regex
 

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo.py

@@ -20,7 +20,7 @@ class Safe_Str__GitHub__Repo(Safe_Str):
     """
     regex                      = TYPE_SAFE_STR__GITHUB__REPO__REGEX
     max_length                 = TYPE_SAFE_STR__GITHUB__REPO__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     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)
@@ -31,16 +31,20 @@ class Safe_Str__GitHub__Repo(Safe_Str):
         
         if result:
             if '/' not in result:                                                                   # Check for the required forward slash
-                raise ValueError(f"GitHub repository must be in 'owner/repo' format: {result}")
+                raise ValueError(f"in {cls.__name__}, 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}")
+                raise ValueError(f"in {cls.__name__}, 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
+            result.repo_name  = Safe_Str__GitHub__Repo_Name(repo_part  )
+            if not result.repo_owner:
+                raise ValueError(f"in {cls.__name__}, missing owner, gitHub repository must be in 'owner/repo' format: {result}")
+            if not result.repo_name:
+                raise ValueError(f"in {cls.__name__}, missing name, gitHub repository must be in 'owner/repo' format: {result}")
         
         return result

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo_Name.py

@@ -15,7 +15,7 @@ class Safe_Str__GitHub__Repo_Name(Safe_Str):
     """
     regex                      = TYPE_SAFE_STR__GITHUB__REPO_NAME__REGEX
     max_length                 = TYPE_SAFE_STR__GITHUB__REPO_NAME__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False
 
@@ -26,10 +26,10 @@ class Safe_Str__GitHub__Repo_Name(Safe_Str):
         if result:
             # Check if it's just periods (reserved names)
             if result in ['.', '..']:
-                raise ValueError(f"Invalid repository name: {result}")
+                raise ValueError(f"in {cls.__name__}, invalid repository name: {result}")
 
             # Check for all replacement characters
             if set(result) == {'_'} and len(result) > 0:
-                raise ValueError(f"Invalid repository name: {result}")
+                raise ValueError(f"in {cls.__name__}, invalid repository name: {result}")
 
         return result

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/github/Safe_Str__GitHub__Repo_Owner.py

@@ -16,7 +16,7 @@ class Safe_Str__GitHub__Repo_Owner(Safe_Str):
     """
     regex                      = TYPE_SAFE_STR__GITHUB__REPO_OWNER__REGEX
     max_length                 = TYPE_SAFE_STR__GITHUB__REPO_OWNER__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False
 
@@ -26,13 +26,13 @@ class Safe_Str__GitHub__Repo_Owner(Safe_Str):
 
         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}")
+                raise ValueError(f"in {cls.__name__}, 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}")
+                raise ValueError(f"in {cls.__name__}, 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}")
+                raise ValueError(f"in {cls.__name__}, invalid GitHub owner name: {result}")
 
         return result
 

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/osbot_utils/type_safe/primitives/safe_str/http/Safe_Str__Http__Content_Type.py

@@ -7,6 +7,6 @@ TYPE_SAFE_STR__HTTP__CONTENT_TYPE__MAX_LENGTH = 256
 class Safe_Str__Http__Content_Type(Safe_Str):
     regex                      = TYPE_SAFE_STR__HTTP__CONTENT_TYPE__REGEX
     max_length                 = TYPE_SAFE_STR__HTTP__CONTENT_TYPE__MAX_LENGTH
-    allow_empty                = False
+    allow_empty                = True
     trim_whitespace            = True
     allow_all_replacement_char = False

osbot_utils-2.85.0/osbot_utils/version

@@ -0,0 +1 @@
+v2.85.0

{osbot_utils-2.84.0 → osbot_utils-2.85.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v2.84.0"
+version     = "v2.85.0"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <dinis.cruz@owasp.org>"]
 license     = "MIT"

osbot_utils-2.84.0/osbot_utils/version

@@ -1 +0,0 @@
-v2.84.0