PyPI - osbot-utils - Versions diffs - 2.55.0__tar.gz → 2.57.0__tar.gz - Mend

osbot-utils 2.55.0tar.gz → 2.57.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 (420) hide show

{osbot_utils-2.55.0 → osbot_utils-2.57.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.55.0
+Version: 2.57.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.55.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.57.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.55.0 → osbot_utils-2.57.0}/README.md RENAMED Viewed

@@ -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.55.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.57.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.55.0/osbot_utils/helpers/html/Dict_To_Css.py → osbot_utils-2.57.0/osbot_utils/helpers/html/CSS_Dict__To__Css.py RENAMED Viewed

@@ -1,7 +1,6 @@
 from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-class Dict_To_Css(Kwargs_To_Self):
+class CSS_Dict__To__Css(Kwargs_To_Self):
     css: dict

osbot_utils-2.57.0/osbot_utils/helpers/html/Html_Dict__To__Html.py ADDED Viewed

@@ -0,0 +1,97 @@
+from osbot_utils.helpers.html.Html__To__Html_Dict import STRING__SCHEMA_TEXT, STRING__SCHEMA_NODES
+HTML_SELF_CLOSING_TAGS     = {'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'}
+HTML_DEFAULT_DOCTYPE_VALUE = "<!DOCTYPE html>\n"
+class Html_Dict__To__Html:
+    def __init__(self, root, include_doctype=True, doctype=HTML_DEFAULT_DOCTYPE_VALUE):
+        self.self_closing_tags = HTML_SELF_CLOSING_TAGS             # Define a list of self-closing tags
+        self.root              = root
+        self.include_doctype   = include_doctype
+        self.doctype           = doctype
+    def convert(self):
+        html = self.convert_element(self.root, 0)
+        if self.include_doctype:
+            return self.doctype + html
+        return html
+    def convert_attrs(self, attrs):
+        attrs_str_parts = []                                                # List to hold each attribute's string representation
+        for key, value in attrs.items():
+            if value is None:                                               # Handle None values
+                attr_str = f'{key}'
+            elif '"' in str(value):                                         # Check if the attribute value contains double quotes
+                escaped_value = "&quot;".join(str(value).split("\""))       # If so, escape double quotes and format the attribute string
+                attr_str      = f'{key}="{escaped_value}"'
+            else:
+                attr_str = f'{key}="{value}"'                               # If not, simply format the attribute string
+            attrs_str_parts.append(attr_str)
+        attrs_str = ' '.join(attrs_str_parts)                               # Join the parts into the final attributes string
+        if attrs_str:
+            attrs_str = " " + attrs_str                                     # Prepend a space if there are attributes
+        return attrs_str
+    def convert_element(self, element, indent_level):
+        """Recursively converts a dictionary to an HTML string with indentation."""
+        # Check if this is a text node
+        if element.get("type") == STRING__SCHEMA_TEXT:
+            return element.get("data", "")                                  # Return text content directly for text nodes
+        tag   = element.get("tag")
+        attrs = element.get("attrs", {})
+        nodes = element.get(STRING__SCHEMA_NODES, [])
+        attrs_str = self.convert_attrs(attrs)                               # Convert attributes dictionary to a string
+        indent = "    " * indent_level                                      # Indentation for the current level, assuming 4 spaces per indent level
+        # Handle self-closing tags
+        if tag in self.self_closing_tags and not nodes:                  # Check if the tag is self-closing and has no nodes
+            return f"{indent}<{tag}{attrs_str} />\n"
+        # Start building the HTML
+        html = f"{indent}<{tag}{attrs_str}>"                                # Opening tag with indentation
+        # Separate nodes into text nodes and element nodes
+        text_nodes    = [node for node in nodes if node.get("type") == STRING__SCHEMA_TEXT]
+        element_nodes = [node for node in nodes if node.get("type") != STRING__SCHEMA_TEXT]
+        # If there are only element nodes, add a newline after the opening tag
+        if element_nodes and not text_nodes:
+            html += "\n"
+        # Process nodes, maintaining the original order but with proper formatting
+        if nodes:
+            # Track if we're currently in a text section or element section
+            # This helps us add newlines only between elements, not text
+            previous_was_element = False
+            for node in nodes:
+                if node.get("type") == STRING__SCHEMA_TEXT:
+                    # Text node - directly append content
+                    html += node.get("data", "")
+                    previous_was_element = False
+                else:
+                    # Element node - format with proper indentation
+                    if previous_was_element:
+                        # If previous child was also an element, we may already have a newline
+                        if not html.endswith("\n"):
+                            html += "\n"
+                    html += self.convert_element(node, indent_level + 1)
+                    previous_was_element = True
+        # Handle closing tag based on content
+        if element_nodes and not text_nodes:
+            # If only element nodes, add indented closing tag
+            html += f"{indent}</{tag}>\n"
+        elif nodes:  # Any type of nodes
+            # If mixed content or only text, add closing tag without indentation
+            html += f"</{tag}>\n"
+        else:
+            # Empty tag, replace with self-contained format
+            html = f"{indent}<{tag}{attrs_str}></{tag}>\n"
+        return html

osbot_utils-2.57.0/osbot_utils/helpers/html/Html_Dict__To__Html_Document.py ADDED Viewed

@@ -0,0 +1,37 @@
+from typing                                                         import Dict, Union, Any
+from osbot_utils.helpers.html.Html__To__Html_Dict                   import STRING__SCHEMA_TEXT, STRING__SCHEMA_NODES
+from osbot_utils.helpers.html.schemas.Schema__Html_Document         import Schema__Html_Document
+from osbot_utils.helpers.html.schemas.Schema__Html_Node             import Schema__Html_Node
+from osbot_utils.helpers.html.schemas.Schema__Html_Node__Data       import Schema__Html_Node__Data
+from osbot_utils.helpers.html.schemas.Schema__Html_Node__Data__Type import Schema__Html_Node__Data__Type
+from osbot_utils.type_safe.Type_Safe                                import Type_Safe
+class Html_Dict__To__Html_Document(Type_Safe):
+    html__dict    : dict                  = None
+    html__document: Schema__Html_Document = None
+    def convert(self):
+        self.html__document = self.parse_html_dict(self.html__dict)
+        return self.html__document
+    def parse_html_dict(self, target: Dict[str, Any]) -> Schema__Html_Document:
+        if not target or not isinstance(target, dict):
+            raise ValueError("Invalid HTML dictionary structure")
+        root_node = self.parse_node(target)
+        return Schema__Html_Document(root_node=root_node)
+    def parse_node(self, target: Dict[str, Any]) -> Union[Schema__Html_Node, Schema__Html_Node__Data]:
+        if target.get('type') == STRING__SCHEMA_TEXT:                                           # Handle text nodes
+            return Schema__Html_Node__Data(data = target.get('data', ''),
+                                           type = Schema__Html_Node__Data__Type.TEXT)
+        else:                                                                                   # Handle element nodes
+            nodes = []
+            for node in target.get(STRING__SCHEMA_NODES, []):
+                nodes.append(self.parse_node(node))
+            return Schema__Html_Node(attrs = target.get('attrs', {})           ,
+                                     nodes = nodes                              ,
+                                     tag   = target.get('tag', ''))

osbot_utils-2.57.0/osbot_utils/helpers/html/Html_Dict__To__Html_Tags.py ADDED Viewed

@@ -0,0 +1,138 @@
+from osbot_utils.helpers.html.Html_Dict__To__Html import HTML_SELF_CLOSING_TAGS
+from osbot_utils.helpers.html.Html__To__Html_Dict import STRING__SCHEMA_TEXT, STRING__SCHEMA_NODES
+from osbot_utils.helpers.html.Tag__Base           import Tag__Base
+from osbot_utils.helpers.html.Tag__Body           import Tag__Body
+from osbot_utils.helpers.html.Tag__Head           import Tag__Head
+from osbot_utils.helpers.html.Tag__Html           import Tag__Html
+from osbot_utils.helpers.html.Tag__Link           import Tag__Link
+from osbot_utils.helpers.html.Tag__Text           import Tag__Text
+class Html_Dict__To__Html_Tags:
+    def __init__(self, root):
+        self.root = root
+    def convert(self):
+        return self.convert_element(self.root)
+    def convert_element(self, element):
+        tag_name = element.get("tag")
+        # Handle special tag types with dedicated conversion methods
+        if tag_name == 'html':
+            return self.convert_to__tag__html(element)
+        elif tag_name == 'head':
+            return self.convert_to__tag__head(element, 0)  # Default indent 0
+        elif tag_name == 'link':
+            return self.convert_to__tag__link(element)
+        else:
+            # Default case: convert to a generic Tag__Base
+            return self.convert_to__tag(Tag__Base, element, 0)  # Default indent 0
+    def collect_inner_text(self, element):
+        """Extract all text from an element's text node nodes."""
+        inner_text = ""
+        for node in element.get(STRING__SCHEMA_NODES, []):
+            if node.get("type") == STRING__SCHEMA_TEXT:
+                inner_text += node.get("data", "")
+        return inner_text
+    def convert_to__tag(self, target_tag, element, indent):
+        if element.get("type") == STRING__SCHEMA_TEXT:
+            # Handle text nodes directly
+            return Tag__Text(element.get("data", ""))
+        tag_name   = element.get("tag")
+        attrs      = element.get("attrs", {})
+        nodes      = element.get(STRING__SCHEMA_NODES, [])
+        end_tag    = tag_name not in HTML_SELF_CLOSING_TAGS
+        tag_indent = indent + 1
+        # Collect inner text from all text node nodes
+        inner_html = self.collect_inner_text(element)
+        tag_kwargs = dict(
+            tag_name   = tag_name,
+            attributes = attrs,
+            end_tag    = end_tag,
+            indent     = tag_indent,
+            inner_html = inner_html
+        )
+        tag = target_tag(**tag_kwargs)
+        # Process only element nodes as nodes (text is already handled via inner_html)
+        for node in nodes:
+            if node.get("type") != STRING__SCHEMA_TEXT:  # Skip text nodes, they're in inner_html
+                child_tag = self.convert_to__tag(Tag__Base, node, tag_indent)
+                tag.elements.append(child_tag)
+        return tag
+    def convert_to__tag__head(self, element, indent):
+        attrs = element.get("attrs", {})
+        nodes = element.get(STRING__SCHEMA_NODES, [])
+        head_indent = indent + 1
+        tag_head = Tag__Head(indent=head_indent, **attrs)
+        for node in nodes:
+            tag_name = node.get("tag")
+            if tag_name == 'title':
+                # Extract title text from text node nodes
+                tag_head.title = self.collect_inner_text(node)
+            elif tag_name == 'link':
+                tag_head.links.append(self.convert_to__tag__link(node))
+            elif tag_name == 'meta':
+                tag_head.elements.append(self.convert_to__tag(Tag__Base, node, head_indent))
+            elif tag_name == 'style':
+                # For style tags, collect the CSS content from text nodes
+                style_element = self.convert_to__tag(Tag__Base, node, head_indent)
+                tag_head.elements.append(style_element)
+            else:
+                # Handle any other head elements
+                tag_head.elements.append(self.convert_to__tag(Tag__Base, node, head_indent))
+        return tag_head
+    def convert_to__tag__html(self, element):
+        attrs = element.get("attrs", {})
+        nodes = element.get(STRING__SCHEMA_NODES, [])
+        lang  = attrs.get("lang")
+        tag_html = Tag__Html(attributes=attrs, lang=lang, doc_type=False)
+        # Initialize head and body if not found
+        head_found = False
+        body_found = False
+        for node in nodes:
+            tag_name = node.get("tag")
+            if tag_name == 'head':
+                tag_html.head = self.convert_to__tag__head(node, tag_html.indent)
+                head_found = True
+            elif tag_name == 'body':
+                tag_html.body = self.convert_to__tag(Tag__Body, node, tag_html.indent)
+                body_found = True
+            else:
+                # Log unexpected child elements of html
+                print(f'Unexpected child of html tag: {tag_name}')
+        # Handle missing head or body (required for valid HTML structure)
+        if not head_found:
+            #print("Warning: No head element found, creating empty one")
+            tag_html.head = Tag__Head(indent=tag_html.indent + 1)
+        if not body_found:
+            #print("Warning: No body element found, creating empty one")
+            tag_html.body = Tag__Body(indent=tag_html.indent + 1)
+        return tag_html
+    def convert_to__tag__link(self, element):
+        attrs    = element.get("attrs", {})
+        tag_link = Tag__Link(**attrs)
+        return tag_link

osbot_utils-2.57.0/osbot_utils/helpers/html/Html__To__Html_Dict.py ADDED Viewed

@@ -0,0 +1,105 @@
+from html.parser import HTMLParser
+HTML_SELF_CLOSING_TAGS = {'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'}
+STRING__SCHEMA_TEXT    = 'TEXT'
+STRING__SCHEMA_NODES   = 'nodes'
+STRING__DATA_TEXT      = f'{STRING__SCHEMA_TEXT}:'
+class Html__To__Html_Dict(HTMLParser):
+    def __init__(self, html):
+        super().__init__()
+        self.root            = None                               # No root initially
+        self.current         = None                               # No current node at the start
+        self.stack           = []                                 # Empty stack for hierarchy management
+        self.html            = html or ''
+        self.void_elements   = HTML_SELF_CLOSING_TAGS             # List of void elements that are self-closing by nature
+        self.strip_text_data = True
+    def convert(self):
+        self.feed(self.html)
+        return self.root
+    def handle_starttag(self, tag, attrs):
+        new_tag = {"tag": tag, "attrs": dict(attrs), STRING__SCHEMA_NODES: []}
+        if self.current is None:
+            # When the first tag is encountered, it becomes the root
+            self.root = new_tag
+            self.current = new_tag
+        else:
+            # Otherwise, append the new tag as a child of the current tag
+            self.current[STRING__SCHEMA_NODES].append(new_tag)
+        # If this tag is not a void element, push it onto the stack
+        if tag.lower() not in self.void_elements:
+            self.stack.append(new_tag)
+            self.current = new_tag
+    def handle_endtag(self, tag):
+        # Find and pop the matching start tag
+        if tag.lower() not in self.void_elements and len(self.stack) > 1:
+            # Look for the matching start tag in the stack
+            for i in range(len(self.stack) - 1, 0, -1):
+                if self.stack[i]["tag"].lower() == tag.lower():
+                    # Pop all tags up to and including the matching start tag
+                    self.stack = self.stack[:i]
+                    break
+            # Update current to the top of stack
+            self.current = self.stack[-1]
+    def handle_data(self, data):
+        if data.strip():  # Ignore whitespace
+            # Create a text node as a child
+            text_node = {"type": STRING__SCHEMA_TEXT, "data": data}
+            self.current[STRING__SCHEMA_NODES].append(text_node)
+    def print__generate_lines(self, node, indent="", last=True, is_root=True):
+        lines = []
+        prefix = "" if is_root else ("└── " if last else "├── ")
+        if node.get("type") == STRING__SCHEMA_TEXT:
+            text_data = node.get('data')
+            if self.strip_text_data:
+                text_data = text_data.strip()
+            lines.append(f"{indent}{prefix}{STRING__DATA_TEXT} {text_data}")
+        else:
+            tag       = node.get("tag")
+            attrs     = node.get("attrs", {})
+            nodes     = node.get(STRING__SCHEMA_NODES, [])
+            attrs_str = ' '.join(f'{key}="{value}"' for key, value in attrs.items())
+            attrs_str = f' ({attrs_str})' if attrs_str else ''
+            lines.append(f"{indent}{prefix}{tag}{attrs_str}")
+            child_indent = indent + ("    " if last else "│   ")
+            for i, node in enumerate(nodes):
+                is_last = i == len(nodes) - 1
+                child_lines = self.print__generate_lines(node, indent=child_indent, last=is_last, is_root=False)
+                lines.extend(child_lines if isinstance(child_lines, list) else [child_lines])
+        return lines if is_root else "\n".join(lines)
+    def print(self, just_return_lines=False):
+        if self.root:
+            lines = self.print__generate_lines(self.root, is_root=True)
+            if just_return_lines:
+                return lines
+            else:
+                self.print__lines(lines)
+        return self
+    def print__lines(self, lines):
+        for line in lines:
+            print(line)
+def html_to_dict(html_code: str) -> dict:
+    try:
+        html_to_dict = Html__To__Html_Dict(html_code)
+        html_dict = html_to_dict.convert()
+        return html_dict
+    except:  # todo: see if there is a better Exception to capture
+        return None  # if we couldn't parse the html, just return None

osbot_utils-2.57.0/osbot_utils/helpers/html/Html__To__Html_Document.py ADDED Viewed

@@ -0,0 +1,19 @@
+from osbot_utils.helpers.html.Html_Dict__To__Html_Document  import Html_Dict__To__Html_Document
+from osbot_utils.helpers.html.Html__To__Html_Dict           import Html__To__Html_Dict
+from osbot_utils.helpers.html.schemas.Schema__Html_Document import Schema__Html_Document
+from osbot_utils.type_safe.Type_Safe                        import Type_Safe
+class Html__To__Html_Document(Type_Safe):
+    html: str
+    html__dict    : dict
+    html__document: Schema__Html_Document
+    def convert(self):
+        if self.html:
+            html__dict =  Html__To__Html_Dict(self.html).convert()
+            if html__dict:
+                with Html_Dict__To__Html_Document(html__dict=html__dict).convert()  as html__document:
+                    if html__document:
+                        self.html__document = html__document
+                        return html__document

osbot_utils-2.57.0/osbot_utils/helpers/html/Html__To__Html_Tag.py ADDED Viewed

@@ -0,0 +1,19 @@
+from osbot_utils.helpers.html.Html_Dict__To__Html_Tags import Html_Dict__To__Html_Tags
+from osbot_utils.helpers.html.Html__To__Html_Dict      import Html__To__Html_Dict
+class Html__To__Html_Tag:
+    def __init__(self,html):
+        self.html_to_dict = Html__To__Html_Dict(html)
+    def __enter__(self):
+        return self.convert()
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return
+    def convert(self):
+        html_dict = self.html_to_dict.convert()
+        html_tag  = Html_Dict__To__Html_Tags(html_dict).convert()
+        return html_tag

{osbot_utils-2.55.0 → osbot_utils-2.57.0}/osbot_utils/helpers/html/Tag__Base.py RENAMED Viewed

@@ -1,11 +1,12 @@
-from collections import defaultdict
+from collections                                import defaultdict
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.utils.Files import file_create
+from osbot_utils.helpers.html.Html__To__Html_Dict import STRING__SCHEMA_TEXT
+from osbot_utils.type_safe.Type_Safe            import Type_Safe
+from osbot_utils.utils.Files                    import file_create
 INDENT_SIZE = 4
-class Tag__Base(Kwargs_To_Self):
+class Tag__Base(Type_Safe):
     attributes               : dict
     elements                 : list
     end_tag                  : bool = True
@@ -54,23 +55,43 @@ class Tag__Base(Kwargs_To_Self):
     def render_element(self):
         html_attributes = self.render_attributes()
-        html_elements   = self.render_elements()
-        element_indent  = " " * self.indent * INDENT_SIZE
+        element_indent = " " * self.indent * INDENT_SIZE
         html = f"{element_indent}<{self.tag_name}"
         if html_attributes:
             html += f" {html_attributes}"
         if self.end_tag:
             html += ">"
+            # Check for text nodes and regular element nodes
+            text_nodes = [e for e in self.elements if hasattr(e, 'type') and e.type == STRING__SCHEMA_TEXT]
+            element_nodes = [e for e in self.elements if not hasattr(e, 'type') or e.type != STRING__SCHEMA_TEXT]
+            has_text = bool(text_nodes) or bool(self.inner_html)
+            has_elements = bool(element_nodes)
+            # Add inner_html if it exists
             if self.inner_html:
                 html += self.inner_html
+            # Get the rendered element HTML
+            html_elements = self.render_elements()
+            # Add element nodes with proper formatting
             if html_elements:
-                if self.new_line_before_elements:
+                # Only add newlines if we have element nodes and no text nodes,
+                # or if we explicitly want newlines before elements
+                if (has_elements and not has_text) or (self.new_line_before_elements and not has_text):
                     html += "\n"
-                html += f"{html_elements}"
-                if self.new_line_before_elements:
+                html += html_elements
+                # Add closing newline and indent only for pure element content
+                if (has_elements and not has_text) or (self.new_line_before_elements and not has_text):
                     html += "\n"
-                html += element_indent
+                    html += element_indent
             html += f"</{self.tag_name}>"
         else:
             html += "/>"
@@ -79,12 +100,23 @@ class Tag__Base(Kwargs_To_Self):
     def render_elements(self):
         html_elements = ""
+        has_element_nodes = False
         for index, element in enumerate(self.elements):
-            if index:
+            # Handle text nodes
+            if hasattr(element, 'type') and element.type == STRING__SCHEMA_TEXT:
+                html_elements += element.data
+                continue
+            # Only add newlines between element nodes (not text nodes)
+            if has_element_nodes:
                 html_elements += '\n'
+            has_element_nodes = True
             element.indent = self.indent + 1        # set the indent of the child element based on the current one
             html_element = element.render()
             html_elements += html_element
         return html_elements
     def render(self):

{osbot_utils-2.55.0 → osbot_utils-2.57.0}/osbot_utils/helpers/html/Tag__Html.py RENAMED Viewed

@@ -1,7 +1,7 @@
 from osbot_utils.helpers.html.Tag__Base import Tag__Base
 from osbot_utils.helpers.html.Tag__Body import Tag__Body
 from osbot_utils.helpers.html.Tag__Head import Tag__Head
-from osbot_utils.utils.Misc import str_to_bytes
+from osbot_utils.utils.Misc             import str_to_bytes
 ATTRIBUTES_NAMES__LINK = ['lang']

{osbot_utils-2.55.0 → osbot_utils-2.57.0}/osbot_utils/helpers/html/Tag__Style.py RENAMED Viewed

@@ -1,10 +1,10 @@
-from osbot_utils.helpers.html.Dict_To_Css import Dict_To_Css
-from osbot_utils.helpers.html.Tag__Base import Tag__Base, INDENT_SIZE
+from osbot_utils.helpers.html.CSS_Dict__To__Css import CSS_Dict__To__Css
+from osbot_utils.helpers.html.Tag__Base         import Tag__Base, INDENT_SIZE
 class Tag__Style(Tag__Base):
     tag_name    : str = 'style'
-    dict_to_css : Dict_To_Css
+    dict_to_css : CSS_Dict__To__Css
     def add_css_entry(self, selector, data):
         self.dict_to_css.add_css_entry(selector,data)

osbot_utils-2.57.0/osbot_utils/helpers/html/Tag__Text.py ADDED Viewed

@@ -0,0 +1,10 @@
+from osbot_utils.helpers.html.Html__To__Html_Dict import STRING__SCHEMA_TEXT
+class Tag__Text:
+    def __init__(self, data=""):
+        self.type = STRING__SCHEMA_TEXT
+        self.data = data
+    def render(self):
+        return self.data

osbot_utils-2.57.0/osbot_utils/helpers/html/schemas/Schema__Html_Document.py ADDED Viewed

@@ -0,0 +1,7 @@
+from osbot_utils.helpers.Timestamp_Now                  import Timestamp_Now
+from osbot_utils.helpers.html.schemas.Schema__Html_Node import Schema__Html_Node
+from osbot_utils.type_safe.Type_Safe                    import Type_Safe
+class Schema__Html_Document(Type_Safe):
+    root_node : Schema__Html_Node                        # Top-level child nodes
+    timestamp: Timestamp_Now

osbot_utils-2.57.0/osbot_utils/helpers/html/schemas/Schema__Html_Node.py ADDED Viewed

@@ -0,0 +1,10 @@
+from typing import Union, List, Dict, Optional
+from osbot_utils.helpers.html.schemas.Schema__Html_Node__Data import Schema__Html_Node__Data
+from osbot_utils.type_safe.Type_Safe                          import Type_Safe
+class Schema__Html_Node(Type_Safe):
+    attrs    : Dict[str, Optional[str]]                                               # HTML attributes (e.g., {'class': 'container'})
+    nodes    : List[Union['Schema__Html_Node', Schema__Html_Node__Data]]    # Child nodes (recursive structure)
+    tag      : str                                                          # HTML tag name (e.g., 'div', 'meta', 'title')

osbot_utils-2.57.0/osbot_utils/helpers/html/schemas/Schema__Html_Node__Data.py ADDED Viewed

@@ -0,0 +1,6 @@
+from osbot_utils.helpers.html.schemas.Schema__Html_Node__Data__Type import Schema__Html_Node__Data__Type
+from osbot_utils.type_safe.Type_Safe                                import Type_Safe
+class Schema__Html_Node__Data(Type_Safe):
+    data     : str                                                                   # Text content
+    type     : Schema__Html_Node__Data__Type  = Schema__Html_Node__Data__Type.TEXT   # Always 'text' for text nodes

osbot_utils-2.57.0/osbot_utils/helpers/html/schemas/Schema__Html_Node__Data__Type.py ADDED Viewed

@@ -0,0 +1,4 @@
+from enum import Enum
+class Schema__Html_Node__Data__Type(Enum):
+    TEXT : str = 'text'

{osbot_utils-2.55.0 → osbot_utils-2.57.0}/osbot_utils/helpers/llms/cache/LLM_Request__Cache.py RENAMED Viewed

@@ -1,13 +1,13 @@
-from typing                                                         import Dict, Optional, List
-from osbot_utils.helpers.Obj_Id                                     import Obj_Id
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Cache__Index      import Schema__LLM_Cache__Index
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Request           import Schema__LLM_Request
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Response          import Schema__LLM_Response
-from osbot_utils.helpers.llms.schemas.Schema__LLM_Response__Cache   import Schema__LLM_Response__Cache
-from osbot_utils.helpers.safe_str.Safe_Str__Hash                    import Safe_Str__Hash
-from osbot_utils.type_safe.Type_Safe                                import Type_Safe
-from osbot_utils.type_safe.decorators.type_safe                     import type_safe
-from osbot_utils.utils.Json                                         import json_md5
+from typing                                                       import Dict, Optional, List
+from osbot_utils.helpers.Obj_Id                                   import Obj_Id
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Cache__Index    import Schema__LLM_Cache__Index
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Request         import Schema__LLM_Request
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Response        import Schema__LLM_Response
+from osbot_utils.helpers.llms.schemas.Schema__LLM_Response__Cache import Schema__LLM_Response__Cache
+from osbot_utils.helpers.safe_str.Safe_Str__Hash                  import Safe_Str__Hash
+from osbot_utils.type_safe.Type_Safe                              import Type_Safe
+from osbot_utils.type_safe.decorators.type_safe                   import type_safe
+from osbot_utils.utils.Json                                       import json_md5
 SIZE__VALUE_HASH = 10

osbot_utils-2.55.0/osbot_utils/helpers/safe_str/Safe_Str__HTML.py → osbot_utils-2.57.0/osbot_utils/helpers/safe_str/Safe_Str__Html.py RENAMED Viewed

@@ -12,6 +12,6 @@ TYPE_SAFE_STR__HTML__MAX_LENGTH = 1048576  # 1 megabyte in bytes
 # - All other Unicode characters
 TYPE_SAFE_STR__HTML__REGEX = re.compile(r'[\x00\x01-\x08\x0B\x0C\x0E-\x1F]')
-class Safe_Str__HTML(Safe_Str):
+class Safe_Str__Html(Safe_Str):
     max_length                 = TYPE_SAFE_STR__HTML__MAX_LENGTH
     regex                      = TYPE_SAFE_STR__HTML__REGEX

osbot-utils 2.55.0__tar.gz → 2.57.0__tar.gz

osbot-utils 2.55.0tar.gz → 2.57.0tar.gz