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

osbot_utils/helpers/safe_str/Safe_Str.py

@@ -1,19 +1,22 @@
 import re
-from typing                                     import Optional
-from osbot_utils.type_safe.Type_Safe__Primitive import Type_Safe__Primitive
+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
-    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
+    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':
@@ -41,14 +44,32 @@ class Safe_Str(Type_Safe__Primitive, str):
         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
+        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:
-            sanitized_value = cls.regex.sub(cls.replacement_char, value)                                                    # Apply regex sanitization
+            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:   # Check if sanitized value consists entirely of replacement characters
-                raise ValueError(f"Sanitized value consists entirely of '{cls.replacement_char}' characters")
+                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 str.__new__(cls, sanitized_value)
+                return sanitized_value

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/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/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/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/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/version

@@ -1 +1 @@
-v2.71.0
+v2.73.0

osbot_utils-2.73.0.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.3
+Name: osbot_utils
+Version: 2.73.0
+Summary: OWASP Security Bot - Utils
+License: MIT
+Author: Dinis Cruz
+Author-email: dinis.cruz@owasp.org
+Requires-Python: >=3.7,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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
+
+# OSBot-Utils
+
+![Current Release](https://img.shields.io/badge/release-v2.73.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)
+[![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
+
+A comprehensive Python utility toolkit providing **Type-Safe primitives**, decorators, caching layers, HTML/AST helpers, SQLite tooling, SSH execution, LLM request pipelines, tracing, and more — all designed to accelerate building robust, maintainable automation and integration code.
+
+---
+
+## ✨ Key Features
+
+* **🛡️ Type-Safe First**: Strongly typed primitives (`Safe_Str`, `Safe_Int`, `Safe_Float`, etc.) with validation and sanitization
+* **⚡ Multi-layer Caching**: In-memory, per-instance, pickle-on-disk, temp-file, and request/response caches
+* **🗂️ Rich Utilities**: Helpers for HTML parsing/rendering, AST inspection, SSH/SCP execution, SQLite schema management, and more
+* **🧠 LLM Support**: Structured request builders, OpenAI API integration, schema enforcement, and persistent cache
+* **🔍 Tracing & Debugging**: Full function call tracing with configurable depth, locals capture, and pretty output
+* **🧪 Testing Utilities**: Temp SQLite DBs, mockable caches, and easy test helpers
+
+---
+
+## 📦 Installation
+
+```bash
+pip install osbot-utils
+```
+
+From source:
+
+```bash
+pip install git+https://github.com/owasp-sbot/OSBot-Utils.git@dev
+```
+
+---
+
+## 🚀 Quick Start
+
+### Using Type-Safe Primitives
+
+```python
+from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+
+class Username(Safe_Str):
+    max_length = 20
+
+print(Username("alice"))  # 'alice'
+print(Username("invalid username!"))  # 'invalid_username_'
+```
+
+---
+
+### Simple In-Memory Caching
+
+```python
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+
+class DataFetcher:
+    @cache_on_self
+    def fetch(self, x):
+        print("Fetching…")
+        return x * 2
+
+fetcher = DataFetcher()
+fetcher.fetch(10)  # Calls method
+fetcher.fetch(10)  # Returns cached result
+```
+
+---
+
+### HTML Parsing
+
+```python
+from osbot_utils.helpers.html.Html__To__Html_Dict import html_to_dict
+
+html_code = "<html><body><h1>Hello</h1></body></html>"
+print(html_to_dict(html_code))
+```
+
+---
+
+### SQLite Dynamic Table
+
+```python
+from osbot_utils.helpers.sqlite.Temp_Sqlite__Table import Temp_Sqlite__Table
+
+with Temp_Sqlite__Table() as table:
+    table.row_schema = type("Row", (), {"name": str, "age": int})
+    table.create()
+    table.add_row_and_commit(name="Alice", age=30)
+    print(table.rows())
+```
+
+---
+
+### LLM Request Execution
+
+```python
+from osbot_utils.helpers.llms.builders.LLM_Request__Builder__Open_AI import LLM_Request__Builder__Open_AI
+from osbot_utils.helpers.llms.actions.LLM_Request__Execute import LLM_Request__Execute
+
+builder = LLM_Request__Builder__Open_AI()
+builder.set__model__gpt_4o().add_message__user("Say hi in JSON")
+
+executor = LLM_Request__Execute(request_builder=builder)
+response = executor.execute(builder.llm_request())
+print(response.response_data)
+```
+
+---
+
+## 🏗️ Architecture
+
+OSBot-Utils is organized into core **Type-Safe foundations** with layered utilities for different domains:
+
+```
+┌──────────────────────────────────────────────┐
+│                 Your Code                     │
+│  ┌───────────┐  ┌─────────────┐  ┌──────────┐ │
+│  │ Type-Safe │  │  Decorators │  │  Helpers │ │
+│  │ Primitives│  │  & Caching  │  │ (HTML,   │ │
+│  │           │  │             │  │  AST,   │ │
+│  │           │  │             │  │  SQLite)│ │
+│  └───────────┘  └─────────────┘  └──────────┘ │
+└──────────────────────────┬───────────────────┘
+                           │
+┌──────────────────────────▼───────────────────┐
+│                OSBot-Utils                    │
+│  ┌────────────────────────────────────────┐  │
+│  │       Type-Safe Core Classes           │  │
+│  │  Validation / Sanitization / Defaults  │  │
+│  └────────────────────────────────────────┘  │
+│  ┌────────────────────────────────────────┐  │
+│  │    Caching Layers & Decorators         │  │
+│  │  @cache, @cache_on_self, pickle, tmp   │  │
+│  └────────────────────────────────────────┘  │
+│  ┌────────────────────────────────────────┐  │
+│  │ Domain Helpers                          │ │
+│  │ HTML, AST, SSH, LLMs, SQLite, Tracing   │ │
+│  └────────────────────────────────────────┘  │
+└──────────────────────────────────────────────┘
+```
+
+---
+
+## 📚 Key Modules
+
+* **`helpers/safe_*`** — Type-Safe primitives for validated strings, ints, floats
+* **`decorators/methods`** — Caching, exception capture, timing, validation
+* **`helpers/html`** — HTML ↔ dict ↔ tag classes
+* **`helpers/ast`** — Python AST parsing, visiting, merging
+* **`helpers/sqlite`** — High-level SQLite APIs, schema generation, temp DBs
+* **`helpers/ssh`** — SSH/SCP execution with caching
+* **`helpers/llms`** — LLM request/response handling with caching
+* **`helpers/trace`** — Function call tracing with configurable output
+
+---
+
+## 🎯 Benefits
+
+### For Developers
+
+* Strong runtime type validation with Type-Safe classes
+* Consistent patterns for caching and decorators
+* Rich helper library to avoid reinventing the wheel
+
+### For Production
+
+* Deterministic caching with persistence options
+* Safe, validated data structures at integration boundaries
+* Lightweight, dependency-minimal utilities
+
+### For Teams
+
+* Standardized approach to cross-cutting concerns (logging, tracing, caching)
+* Modular helpers to fit many contexts (CLI, web apps, serverless)
+
+---
+
+## 🤝 Contributing
+
+Pull requests are welcome!
+Check existing patterns in `/helpers` and `/decorators` for style guidance.
+
+---
+
+## 📄 License
+
+Licensed under the Apache 2.0 License.
+

{osbot_utils-2.71.0.dist-info → osbot_utils-2.73.0.dist-info}/RECORD

@@ -261,20 +261,24 @@ osbot_utils/helpers/safe_int/Safe_UInt__FileSize.py,sha256=pj1_Gf48JVXbnnvx5-Yqb
 osbot_utils/helpers/safe_int/Safe_UInt__Percentage.py,sha256=Ck-jiu6NK57Y3ruAjIJ0k-maiKcB2Q7M3t9nKf-8ga8,357
 osbot_utils/helpers/safe_int/Safe_UInt__Port.py,sha256=uISrh8VKXiEQULQ1POU9YK8Di6z_vr0HWjCTpjA0YaY,482
 osbot_utils/helpers/safe_int/__init__.py,sha256=kMU2WMsdQmayBEZugxnJV_wRW3O90bc118sx6iIm_mQ,310
-osbot_utils/helpers/safe_str/Safe_Str.py,sha256=qR2RDh5cehP_wDDeV5TQahNBwmfcizPFyStALBKD5dw,3509
+osbot_utils/helpers/safe_str/Safe_Str.py,sha256=lVrji7bTDzJIRr20tjsKLEZsKVFrx5AlCQnj-pIe32k,4616
 osbot_utils/helpers/safe_str/Safe_Str__File__Name.py,sha256=9Evl4P45GCyyR2ywze29GzmqWhyTCcgI-o2CItMsOHo,358
 osbot_utils/helpers/safe_str/Safe_Str__File__Path.py,sha256=K0yBcvH_Ncqiw7tMqjGqaNyWQh1Zs9qxZ-TR8nEIAow,550
 osbot_utils/helpers/safe_str/Safe_Str__Hash.py,sha256=IpYdYwXey5WZWa6QfysmsiDP-4L-wP-_EKbkeXhFRH4,1252
 osbot_utils/helpers/safe_str/Safe_Str__Text.py,sha256=QxuWqF8hNYdOPDn3Yac86h_1ZaX-THbTBDakberiJcs,313
 osbot_utils/helpers/safe_str/Safe_Str__Text__Dangerous.py,sha256=6-fkXBuWgjz70eQicD07f38eEuKqNzJzaFFY6hozhNQ,388
 osbot_utils/helpers/safe_str/Safe_Str__Url.py,sha256=4l46AAe5Dy_P_W6d-_3pwtXuehG_Wczq1dC5sOOzg_g,549
+osbot_utils/helpers/safe_str/Safe_Str__Version.py,sha256=atUpMDUbDQWUXUHKkmeMEqSlZGkhNgVInDiOXXQV3kM,1387
 osbot_utils/helpers/safe_str/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/safe_str/http/Safe_Str__Html.py,sha256=4_UxGEIkqV_Zeh77nXoO2OUy5SS6gvN3xSwA32DyWs0,662
 osbot_utils/helpers/safe_str/http/Safe_Str__Http__Content_Type.py,sha256=HURT4n17LmKbcqODsNwhu_D0lI5LpUL8I5t9aqGAZhQ,516
 osbot_utils/helpers/safe_str/http/Safe_Str__Http__ETag.py,sha256=5cAfIqebraUnVKZJq3CzXzsFdHGy06TznO36Dc6b5A0,477
 osbot_utils/helpers/safe_str/http/Safe_Str__Http__Last_Modified.py,sha256=FBcPM4h3ldN0F_cSISGZgdidWpjKLCOOPq9sWVGUCzg,438
 osbot_utils/helpers/safe_str/http/Safe_Str__Http__Text.py,sha256=w0UPkVnQz41BN9asgDUZ4q6pSQUtzNa-4Sjcl56WTCM,1788
+osbot_utils/helpers/safe_str/http/Safe_Str__IP_Address.py,sha256=wOcEt0adsE6-CX08erlRYyGyOLoe4QRaAYdI6sKyKlM,1672
 osbot_utils/helpers/safe_str/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osbot_utils/helpers/safe_str/schemas/Enum__Safe_Str__Regex_Mode.py,sha256=15y_afYIf_LsweutaVVdIJ0qClbVITJGWNEqfRKapNI,120
+osbot_utils/helpers/safe_str/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/sqlite/Capture_Sqlite_Error.py,sha256=GSuRYgs1yKQjxMszPoaI7fsfMfuUqhb64AaIysRE6Cs,1747
 osbot_utils/helpers/sqlite/Sqlite__Cursor.py,sha256=4Im0pCOiERX6Nnf6iagRlSvTR3CPjyPVkdx4NMQV0P0,3342
 osbot_utils/helpers/sqlite/Sqlite__Database.py,sha256=ORjRUD-xSvf89kDMQ70q7wBlbV5pdKtDerjE6gDN_fg,5616
@@ -361,7 +365,7 @@ osbot_utils/testing/Temp_Env_Vars.py,sha256=C1jHGtessu4Q3_EJCkkOsQWSvKPFcilVFsCx
 osbot_utils/testing/Temp_File.py,sha256=yZBL9MmcNU4PCQ4xlF4rSss4GylKoX3T_AJF-BlQhdI,1693
 osbot_utils/testing/Temp_Folder.py,sha256=Dbcohr2ciex6w-kB79R41Nuoa0pgpDbKtPGnlMmJ73k,5194
 osbot_utils/testing/Temp_Sys_Path.py,sha256=gOMD-7dQYQlejoDYUqsrmuZQ9DLC07ymPZB3zYuNmG4,256
-osbot_utils/testing/Temp_Web_Server.py,sha256=0A-gZsd0_3wRj2YuBEOWyV2rhT6dcS2BlArngPXGTtk,3186
+osbot_utils/testing/Temp_Web_Server.py,sha256=pdEshrdoCQWmP962pgPm8JbPG3VQNjH_Wk4rDk1JKZM,3313
 osbot_utils/testing/Temp_Zip.py,sha256=gppbJchk4tw_bu-7Vt6iJS9mGxeCvNNMMDzeVKHqRv8,1489
 osbot_utils/testing/Temp_Zip_In_Memory.py,sha256=ibDIWt3K4CX558PbkLbX3InHyWYZcwQwajFm1kAPW5U,3284
 osbot_utils/testing/Unit_Test.py,sha256=MReR_wDGbbXFDPz7cmuGflcTxRB6TBnO9mYqRpSq8Pk,1304
@@ -416,7 +420,7 @@ osbot_utils/utils/Env.py,sha256=rBksAy6k-J5oAJp-S_JedVlcj1b2VK8V3zsQbacopMc,6076
 osbot_utils/utils/Exceptions.py,sha256=KyOUHkXQ_6jDTq04Xm261dbEZuRidtsM4dgzNwSG8-8,389
 osbot_utils/utils/Files.py,sha256=Zg8TV8RpKv3ytnZvvT17DWeEJCisSkO8zzyP_Twhcww,23449
 osbot_utils/utils/Functions.py,sha256=VoTrAbCHt6hulz6hVz3co8w2xoOS8wE04wyHc5_cC1c,3671
-osbot_utils/utils/Http.py,sha256=pLDwq0Jd4Zmpps0gEzXTbeycSFRXMN8W-DprNpYq9A0,8189
+osbot_utils/utils/Http.py,sha256=cbymd0YJjflI0K0gfq_ie4Speq-Ugko753VCSlYZuf4,8101
 osbot_utils/utils/Int.py,sha256=PmlUdU4lSwf4gJdmTVdqclulkEp7KPCVUDO6AcISMF4,116
 osbot_utils/utils/Json.py,sha256=TvfDoXwOkWzWH-9KMnme5C7iFsMZOleAeue92qmkH6g,8831
 osbot_utils/utils/Json_Cache.py,sha256=mLPkkDZN-3ZVJiDvV1KBJXILtKkTZ4OepzOsDoBPhWg,2006
@@ -434,8 +438,8 @@ osbot_utils/utils/Toml.py,sha256=Rxl8gx7mni5CvBAK-Ai02EKw-GwtJdd3yeHT2kMloik,166
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
 osbot_utils/utils/Zip.py,sha256=mG42lgTY0tnm14T3P1-DSAIZKkTiYoO3odZ1aOUdc1I,14394
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=C1FnkT-V6vyUQrdGCxbq8JOwWMbcdmOn8wCb4q1aMUA,8
-osbot_utils-2.71.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.71.0.dist-info/METADATA,sha256=1JTIsnZagWuiMiblurRoyjA7L2AstKWf4a7jkFfTnc0,1329
-osbot_utils-2.71.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.71.0.dist-info/RECORD,,
+osbot_utils/version,sha256=VCxgw8bSna_rDix4JFMV7Wb8rA3m_O27X41oEA5IP7c,8
+osbot_utils-2.73.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.73.0.dist-info/METADATA,sha256=XGCwVDdvQ37eGSObzfovrfDGt-F4hJNsXsyeyRYh5X4,7892
+osbot_utils-2.73.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.73.0.dist-info/RECORD,,

osbot_utils-2.71.0.dist-info/METADATA

@@ -1,44 +0,0 @@
-Metadata-Version: 2.3
-Name: osbot_utils
-Version: 2.71.0
-Summary: OWASP Security Bot - Utils
-License: MIT
-Author: Dinis Cruz
-Author-email: dinis.cruz@owasp.org
-Requires-Python: >=3.7,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-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
-
-# OSBot-Utils
-
-Powerful Python util methods and classes that simplify common apis and tasks.
-
-![Current Release](https://img.shields.io/badge/release-v2.71.0-blue)
-[![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
-
-
-
-## Install - Release 1.x
-
-**for main branch**: just get it from pypi
-
-```
-pip install osbot-utils
-```
-
-**for dev branch**: add to requirements.txt
-
-```
-git+https://github.com/owasp-sbot/OSBot-Utils.git@dev
-```
-