PyPI - osbot-utils - Versions diffs - 2.54.0__tar.gz → 2.56.0__tar.gz - Mend

osbot-utils 2.54.0tar.gz → 2.56.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 (413) hide show

{osbot_utils-2.54.0 → osbot_utils-2.56.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.54.0
+Version: 2.56.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.54.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.56.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.54.0 → osbot_utils-2.56.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.54.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.56.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.54.0/osbot_utils/helpers/html/Dict_To_Css.py → osbot_utils-2.56.0/osbot_utils/helpers/html/Dict__To__Css.py RENAMED Viewed

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

osbot_utils-2.56.0/osbot_utils/helpers/html/Dict__To__Html.py ADDED Viewed

@@ -0,0 +1,95 @@
+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 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") == "text":
+            return element.get("data", "")                                  # Return text content directly for text nodes
+        tag      = element.get("tag")
+        attrs    = element.get("attrs", {})
+        children = element.get("children", [])
+        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 children:                  # Check if the tag is self-closing and has no children
+            return f"{indent}<{tag}{attrs_str} />\n"
+        # Start building the HTML
+        html = f"{indent}<{tag}{attrs_str}>"                                # Opening tag with indentation
+        # Separate children into text nodes and element nodes
+        text_nodes = [child for child in children if child.get("type") == "text"]
+        element_nodes = [child for child in children if child.get("type") != "text"]
+        # If there are only element nodes, add a newline after the opening tag
+        if element_nodes and not text_nodes:
+            html += "\n"
+        # Process children, maintaining the original order but with proper formatting
+        if children:
+            # 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 child in children:
+                if child.get("type") == "text":
+                    # Text node - directly append content
+                    html += child.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(child, indent_level + 1)
+                    previous_was_element = True
+        # Handle closing tag based on content
+        if element_nodes and not text_nodes:
+            # If only element children, add indented closing tag
+            html += f"{indent}</{tag}>\n"
+        elif children:  # Any type of children
+            # 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.56.0/osbot_utils/helpers/html/Dict__To__Tags.py ADDED Viewed

@@ -0,0 +1,137 @@
+from osbot_utils.helpers.html.Dict__To__Html import HTML_SELF_CLOSING_TAGS
+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 Dict__To__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 children."""
+        inner_text = ""
+        for child in element.get("children", []):
+            if child.get("type") == "text":
+                inner_text += child.get("data", "")
+        return inner_text
+    def convert_to__tag(self, target_tag, element, indent):
+        if element.get("type") == "text":
+            # Handle text nodes directly
+            return Tag__Text(element.get("data", ""))
+        tag_name   = element.get("tag")
+        attrs      = element.get("attrs", {})
+        children   = element.get("children", [])
+        end_tag    = tag_name not in HTML_SELF_CLOSING_TAGS
+        tag_indent = indent + 1
+        # Collect inner text from all text node children
+        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 children (text is already handled via inner_html)
+        for child in children:
+            if child.get("type") != "text":  # Skip text nodes, they're in inner_html
+                child_tag = self.convert_to__tag(Tag__Base, child, tag_indent)
+                tag.elements.append(child_tag)
+        return tag
+    def convert_to__tag__head(self, element, indent):
+        attrs    = element.get("attrs", {})
+        children = element.get("children", [])
+        head_indent = indent + 1
+        tag_head = Tag__Head(indent=head_indent, **attrs)
+        for child in children:
+            tag_name = child.get("tag")
+            if tag_name == 'title':
+                # Extract title text from text node children
+                tag_head.title = self.collect_inner_text(child)
+            elif tag_name == 'link':
+                tag_head.links.append(self.convert_to__tag__link(child))
+            elif tag_name == 'meta':
+                tag_head.elements.append(self.convert_to__tag(Tag__Base, child, head_indent))
+            elif tag_name == 'style':
+                # For style tags, collect the CSS content from text nodes
+                style_element = self.convert_to__tag(Tag__Base, child, head_indent)
+                tag_head.elements.append(style_element)
+            else:
+                # Handle any other head elements
+                tag_head.elements.append(self.convert_to__tag(Tag__Base, child, head_indent))
+        return tag_head
+    def convert_to__tag__html(self, element):
+        attrs    = element.get("attrs", {})
+        children = element.get("children", [])
+        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 child in children:
+            tag_name = child.get("tag")
+            if tag_name == 'head':
+                tag_html.head = self.convert_to__tag__head(child, tag_html.indent)
+                head_found = True
+            elif tag_name == 'body':
+                tag_html.body = self.convert_to__tag(Tag__Body, child, 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.56.0/osbot_utils/helpers/html/Html__To__Dict.py ADDED Viewed

@@ -0,0 +1,102 @@
+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__DATA_TEXT = 'TEXT:'
+class Html__To__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), "children": []}
+        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["children"].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": "text", "data": data}
+            self.current["children"].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") == "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", {})
+            children  = node.get("children", [])
+            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, child in enumerate(children):
+                is_last = i == len(children) - 1
+                child_lines = self.print__generate_lines(child, 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__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.56.0/osbot_utils/helpers/html/Html__To__Tag.py ADDED Viewed

@@ -0,0 +1,19 @@
+from osbot_utils.helpers.html.Dict__To__Tags import Dict__To__Tags
+from osbot_utils.helpers.html.Html__To__Dict import Html__To__Dict
+class Html__To__Tag:
+    def __init__(self,html):
+        self.html_to_dict = Html__To__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  = Dict__To__Tags(html_dict).convert()
+        return html_tag

{osbot_utils-2.54.0 → osbot_utils-2.56.0}/osbot_utils/helpers/html/Tag__Base.py RENAMED Viewed

@@ -1,11 +1,10 @@
-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 collections                                import defaultdict
+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 +53,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 == 'text']
+            element_nodes = [e for e in self.elements if not hasattr(e, 'type') or e.type != '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 children 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 +98,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 == '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.54.0 → osbot_utils-2.56.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.54.0 → osbot_utils-2.56.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.Dict__To__Css import 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 : Dict__To__Css
     def add_css_entry(self, selector, data):
         self.dict_to_css.add_css_entry(selector,data)

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

@@ -0,0 +1,7 @@
+class Tag__Text:
+    def __init__(self, data=""):
+        self.type = "text"
+        self.data = data
+    def render(self):
+        return self.data

{osbot_utils-2.54.0 → osbot_utils-2.56.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.56.0/osbot_utils/helpers/safe_str/Safe_Str__Html.py ADDED Viewed

@@ -0,0 +1,17 @@
+import re
+from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+# Define the size constant
+TYPE_SAFE_STR__HTML__MAX_LENGTH = 1048576  # 1 megabyte in bytes
+# A minimal regex that only filters out:
+# - NULL byte (U+0000)
+# - Control characters (U+0001 to U+0008, U+000B to U+000C, U+000E to U+001F)
+# We explicitly allow:
+# - Tab (U+0009), Line Feed (U+000A), and Carriage Return (U+000D)
+# - 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):
+    max_length                 = TYPE_SAFE_STR__HTML__MAX_LENGTH
+    regex                      = TYPE_SAFE_STR__HTML__REGEX

{osbot_utils-2.54.0 → osbot_utils-2.56.0}/osbot_utils/helpers/safe_str/Safe_Str__Text__Dangerous.py RENAMED Viewed

@@ -6,7 +6,4 @@ TYPE_SAFE_STR__TEXT__DANGEROUS__REGEX      = r'[^a-zA-Z0-9_\s!@#$%^&*()\[\]{}\-+
 class Safe_Str__Text__Dangerous(Safe_Str):
     regex      = re.compile(TYPE_SAFE_STR__TEXT__DANGEROUS__REGEX)
-    max_length = TYPE_SAFE_STR__TEXT__DANGEROUS__MAX_LENGTH
-Safe_Str__HTML = Safe_Str__Text__Dangerous          # we can reuse this class for Safe_Str__HTML since the regex and size are the same
+    max_length = TYPE_SAFE_STR__TEXT__DANGEROUS__MAX_LENGTH

osbot_utils-2.56.0/osbot_utils/version ADDED Viewed

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

{osbot_utils-2.54.0 → osbot_utils-2.56.0}/pyproject.toml RENAMED Viewed

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

osbot_utils-2.54.0/osbot_utils/helpers/html/Dict_To_Html.py DELETED Viewed

@@ -1,59 +0,0 @@
-HTML_SELF_CLOSING_TAGS = {'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'}
-class Dict_To_Html:
-    def __init__(self, root):
-        # Define a list of self-closing tags
-        self.self_closing_tags =HTML_SELF_CLOSING_TAGS # {'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'}
-        self.root = root
-    def convert(self):
-        return self.convert_element(self.root, 0)               # Start conversion with the root element and initial indentation level 0
-    def convert_attrs(self, attrs):
-        attrs_str_parts = []                                                # List to hold each attribute's string representation
-        for key, value in attrs.items():
-            if '"' in value:                                                # Check if the attribute value contains double quotes
-                escaped_value = "&quot;".join(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."""
-        tag      = element.get("tag")
-        attrs    = element.get("attrs", {})
-        children = element.get("children", [])
-        data     = element.get("data", "")
-        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
-        if tag in self.self_closing_tags:                               # Check if the tag is self-closing
-            return f"{indent}<{tag}{attrs_str} />\n"
-        html = f"{indent}<{tag}{attrs_str}>"                            # Opening tag with indentation
-        if not data:
-            html += '\n'
-        for child in children:                                          # Process children with incremented indent level
-            html += self.convert_element(child, indent_level + 1)
-        if data:                                                        # Add data if present
-            html += data
-        if children:                                                    # Closing tag for non-self-closing tags, with indentation
-            html += f"{indent}</{tag}>\n"                               # Add closing tag on a new line if there are children
-        elif data:
-            html += f"</{tag}>\n"
-        else:                                                           # Place closing tag directly after opening tag if there are no children or data
-            html = f"{indent}<{tag}{attrs_str}></{tag}>\n"
-        return html

osbot-utils 2.54.0__tar.gz → 2.56.0__tar.gz

osbot-utils 2.54.0tar.gz → 2.56.0tar.gz