PyPI - osbot-utils - Versions diffs - 2.71.0__tar.gz → 2.73.0__tar.gz - Mend

osbot-utils 2.71.0tar.gz → 2.73.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (449) hide show

osbot_utils-2.73.0/PKG-INFO ADDED Viewed

@@ -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.73.0/README.md ADDED Viewed

@@ -0,0 +1,190 @@
+# 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.73.0/osbot_utils/helpers/safe_str/Safe_Str.py ADDED Viewed

@@ -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.73.0/osbot_utils/helpers/safe_str/Safe_Str__Version.py ADDED Viewed

@@ -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.73.0/osbot_utils/helpers/safe_str/http/Safe_Str__IP_Address.py ADDED Viewed

@@ -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.73.0/osbot_utils/helpers/safe_str/schemas/Enum__Safe_Str__Regex_Mode.py ADDED Viewed

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

{osbot_utils-2.71.0 → osbot_utils-2.73.0}/osbot_utils/testing/Temp_Web_Server.py RENAMED Viewed

@@ -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.71.0 → osbot_utils-2.73.0}/osbot_utils/utils/Http.py RENAMED Viewed

@@ -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.73.0/osbot_utils/utils/__init__.py ADDED Viewed

File without changes

osbot_utils-2.73.0/osbot_utils/version ADDED Viewed

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

{osbot_utils-2.71.0 → osbot_utils-2.73.0}/pyproject.toml RENAMED Viewed

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

osbot_utils-2.71.0/PKG-INFO DELETED Viewed

@@ -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
-```

osbot-utils 2.71.0__tar.gz → 2.73.0__tar.gz

osbot-utils 2.71.0tar.gz → 2.73.0tar.gz