osbot-utils 2.70.0__tar.gz → 2.72.0__tar.gz

{osbot_utils-2.70.0 → osbot_utils-2.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.70.0
+Version: 2.72.0
 Summary: OWASP Security Bot - Utils
 License: MIT
 Author: Dinis Cruz
@@ -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.70.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.72.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.70.0 → osbot_utils-2.72.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.70.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.72.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.72.0/osbot_utils/helpers/safe_str/Safe_Str.py

@@ -0,0 +1,75 @@
+import re
+from typing                                                          import Optional
+from osbot_utils.helpers.safe_str.schemas.Enum__Safe_Str__Regex_Mode import Enum__Safe_Str__Regex_Mode
+from osbot_utils.type_safe.Type_Safe__Primitive                      import Type_Safe__Primitive
+
+TYPE_SAFE__STR__REGEX__SAFE_STR = re.compile(r'[^a-zA-Z0-9]')    # Only allow alphanumerics and numbers
+TYPE_SAFE__STR__MAX_LENGTH      = 512
+
+
+class Safe_Str(Type_Safe__Primitive, str):
+    max_length                : int                        = TYPE_SAFE__STR__MAX_LENGTH
+    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
+    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
+    exact_length              : bool                       = False               # If True, require exact length match, not just max length
+
+
+    def __new__(cls, value: Optional[str] = None) -> 'Safe_Str':
+
+        if value is None:                                                                                               # Validate inputs
+            if cls.allow_empty:
+                value = ""
+            else:
+                raise ValueError(f"in {cls.__name__}, value cannot be None when allow_empty is False") from None
+
+        if not isinstance(value, str):                                                                                  # Convert to string if not already
+            value = str(value)
+
+        if cls.trim_whitespace:                                                                                         # Trim whitespace if requested
+            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")
+
+        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)})")
+        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)})")
+
+        if cls.allow_empty and value =='':
+            return str.__new__(cls, '')
+
+        sanitized_value = cls.validate_and_sanitize(value)
+
+
+        return str.__new__(cls, sanitized_value)
+
+    @classmethod
+    def validate_and_sanitize(cls, value):
+        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}")
+                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})")
+                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")
+            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")
+
+                return sanitized_value

osbot_utils-2.72.0/osbot_utils/helpers/safe_str/Safe_Str__Version.py

@@ -0,0 +1,20 @@
+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
+
+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'
+
+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
+    trim_whitespace   = True
+    strict_validation = True                                                                        # Ensure the value exactly matches the regex
+
+    def __add__(self, other):                                                                       # Concatenation returns regular str, not Safe_Str__Version
+        return str.__add__(self, other)
+
+    def __radd__(self, other):                                                                      # Reverse concatenation also returns regular str
+        return str.__add__(other, self)

osbot_utils-2.72.0/osbot_utils/helpers/safe_str/http/Safe_Str__IP_Address.py

@@ -0,0 +1,29 @@
+import ipaddress
+from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+
+
+class Safe_Str__IP_Address(Type_Safe__Primitive, str):
+
+    def __new__(cls, value: str = None):
+        if value is not None:                                                                   # check that it is not None
+            if not isinstance(value, str):                                                      # check that it is a string
+                raise TypeError(f"Value provided must be a string, and it was {type(value)}")
+            else:
+                value = value.strip()                                                           # trim/strip the value since there could be some leading spaces (which are easy to fix here)
+
+        if not value:                                                                           # allow empty or null values
+            return str.__new__(cls, "")
+
+        try:
+            ip_obj = ipaddress.ip_address(value)                                                # validate IP address using ipaddress module
+            value = str(ip_obj)                                                                 # Use the canonical representation
+        except ValueError as e:
+            raise ValueError(f"Invalid IP address: {value}") from e
+
+        return str.__new__(cls, value)
+
+    def __add__(self, other):                                           # Concatenation returns regular str, not Safe_Str__IP_Address
+        return str.__add__(self, other)
+
+    def __radd__(self, other):                                          # Reverse concatenation also returns regular str"""
+        return str.__add__(other, self)

osbot_utils-2.72.0/osbot_utils/helpers/safe_str/schemas/Enum__Safe_Str__Regex_Mode.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+class Enum__Safe_Str__Regex_Mode(Enum):
+    REPLACE : str = 'replace'
+    MATCH   : str = 'match'

{osbot_utils-2.70.0 → osbot_utils-2.72.0}/osbot_utils/testing/Temp_Env_Vars.py

@@ -1,6 +1,6 @@
 import os
 from osbot_utils.type_safe.Type_Safe import Type_Safe
-from osbot_utils.utils.Env              import del_env, set_env
+from osbot_utils.utils.Env           import del_env, set_env
 
 
 class Temp_Env_Vars(Type_Safe):

{osbot_utils-2.70.0 → osbot_utils-2.72.0}/osbot_utils/testing/Temp_Web_Server.py

@@ -1,14 +1,11 @@
-from contextlib import contextmanager
-from functools import partial
-from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
-from threading import Thread
-from urllib.parse import urljoin
-
-from osbot_utils.utils.Files import file_create, path_combine, temp_filename, file_create_all_parent_folders
-
-from osbot_utils.utils.Misc import random_port, random_string
-
-from osbot_utils.utils.Http import port_is_open, GET
+from contextlib                 import contextmanager
+from functools                  import partial
+from http.server                import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from threading                  import Thread
+from urllib.parse               import urljoin
+from osbot_utils.utils.Files    import file_create, path_combine, temp_filename, file_create_all_parent_folders
+from osbot_utils.utils.Misc     import random_port, random_string
+from osbot_utils.utils.Http     import port_is_open, GET
 
 
 class Temp_Web_Server:
@@ -67,6 +64,7 @@ class Temp_Web_Server:
             self.server_thread.join()
         else:
             self.server._BaseServer__shutdown_request = True  # simulate what happens inside self.server.shutdown()
+        return self
 
     def start(self):
         if self.http_handler is  SimpleHTTPRequestHandler:
@@ -76,6 +74,7 @@ class Temp_Web_Server:
         self.server        = ThreadingHTTPServer((self.host, self.port), handler_config)
         self.server_thread = Thread(target=self.server.serve_forever, name=self.server_name)
         self.server_thread.start()
+        return self
 
     def url(self,path=''):
         base_url = f"http://{self.host}:{self.port}"

{osbot_utils-2.70.0 → osbot_utils-2.72.0}/osbot_utils/utils/Http.py

@@ -1,20 +1,15 @@
 import json
-import os
 import re
 import socket
 import ssl
 import unicodedata
-from http.cookies       import SimpleCookie
-from time               import sleep
-from urllib.parse       import quote, urljoin, urlparse
-from   urllib.request   import Request, urlopen
-
-from osbot_utils.utils.Str import html_decode
-
-from osbot_utils.utils.Misc import url_decode
-
-from osbot_utils.utils.Files import save_bytes_as_file, file_size, file_bytes, file_open_bytes, file_create
-from osbot_utils.utils.Python_Logger import Python_Logger
+from http.cookies            import SimpleCookie
+from time                    import sleep
+from urllib.parse            import quote, urljoin, urlparse
+from   urllib.request        import Request, urlopen
+from osbot_utils.utils.Str   import html_decode
+from osbot_utils.utils.Misc  import url_decode
+from osbot_utils.utils.Files import save_bytes_as_file, file_create
 
 URL_CHECK_HOST_ONLINE         = 'https://www.google.com'
 URL_JOIN_SAFE__MAX_ITERATIONS = 5

{osbot_utils-2.70.0 → osbot_utils-2.72.0}/osbot_utils/utils/Objects.py

@@ -2,7 +2,9 @@
 from types  import SimpleNamespace
 
 class __(SimpleNamespace):
-    pass
+
+    def __enter__(self)                          : return self
+    def __exit__(self, exc_type, exc_val, exc_tb): return False
 
 def base_classes(cls):
     if type(cls) is type:

osbot_utils-2.72.0/osbot_utils/version

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

{osbot_utils-2.70.0 → osbot_utils-2.72.0}/pyproject.toml

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

osbot_utils-2.70.0/osbot_utils/helpers/safe_str/Safe_Str.py

@@ -1,54 +0,0 @@
-import re
-from typing                                     import Optional
-from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
-
-TYPE_SAFE__STR__REGEX__SAFE_STR = re.compile(r'[^a-zA-Z0-9]')    # Only allow alphanumerics and numbers
-TYPE_SAFE__STR__MAX_LENGTH      = 512
-
-class Safe_Str(Type_Safe__Primitive, str):
-    max_length                : int           = TYPE_SAFE__STR__MAX_LENGTH
-    regex                     : re.Pattern    = TYPE_SAFE__STR__REGEX__SAFE_STR
-    replacement_char          : str           = '_'
-    allow_empty               : bool          = 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
-    exact_length              : bool          = False               # If True, require exact length match, not just max length
-
-
-    def __new__(cls, value: Optional[str] = None) -> 'Safe_Str':
-
-        if value is None:                                                                                               # Validate inputs
-            if cls.allow_empty:
-                value = ""
-            else:
-                raise ValueError(f"in {cls.__name__}, value cannot be None when allow_empty is False") from None
-
-        if not isinstance(value, str):                                                                                  # Convert to string if not already
-            value = str(value)
-
-        if cls.trim_whitespace:                                                                                         # Trim whitespace if requested
-            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")
-
-        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)})")
-        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)})")
-
-        if cls.allow_empty and value =='':
-            return str.__new__(cls, '')
-
-        if cls.strict_validation:                                                                                       # If using strict validation, check if the value matches the regex pattern exactly
-            if not cls.regex.search(value) is None:                                                                     # If there are non-matching characters
-                raise ValueError(f"Value contains invalid characters (must match pattern: {cls.regex.pattern})")
-            sanitized_value = value
-        else:
-            sanitized_value = cls.regex.sub(cls.replacement_char, value)                                                    # Apply regex sanitization
-
-            if not cls.allow_all_replacement_char and set(sanitized_value) == {cls.replacement_char} and sanitized_value:   # Check if sanitized value consists entirely of replacement characters
-                raise ValueError(f"Sanitized value consists entirely of '{cls.replacement_char}' characters")
-
-        return str.__new__(cls, sanitized_value)

osbot_utils-2.70.0/osbot_utils/version

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