PyPI - osbot-utils - Versions diffs - 2.67.0__tar.gz → 2.68.0__tar.gz - Mend

osbot-utils 2.67.0tar.gz → 2.68.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 (445) hide show

{osbot_utils-2.67.0 → osbot_utils-2.68.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.67.0
+Version: 2.68.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.67.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.68.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.67.0 → osbot_utils-2.68.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.67.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.68.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.68.0/osbot_utils/helpers/html/Html_Dict__To__Html.py ADDED Viewed

@@ -0,0 +1,112 @@
+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,  # Root element dictionary
+                 include_doctype=True,  # Whether to include DOCTYPE
+                 doctype=HTML_DEFAULT_DOCTYPE_VALUE  # DOCTYPE string to use
+                 ):
+        self.self_closing_tags = HTML_SELF_CLOSING_TAGS
+        self.root = root
+        self.include_doctype = include_doctype
+        self.doctype = doctype
+    def convert(self):  # Convert dictionary to HTML string
+        if not self.root:
+            return ""
+        html = self.convert_element(self.root, 0)
+        if self.include_doctype and self.root.get("tag") == "html":  # Only add DOCTYPE for html root
+            return self.doctype + html
+        return html
+    def convert_attrs(self, attrs):  # Convert attributes dict to HTML string
+        if not attrs:
+            return ""
+        attrs_str_parts = []
+        for key, value in attrs.items():  # Preserve original order
+            if value is None:
+                attr_str = f'{key}'
+            elif value == "":  # Handle empty string values
+                attr_str = f'{key}=""'
+            elif '"' in str(value) and "'" in str(value):  # Both quotes present
+                escaped_value = str(value).replace('"', '&quot;')
+                attr_str = f'{key}="{escaped_value}"'
+            elif '"' in str(value):  # Use single quotes if double quotes present
+                attr_str = f"{key}='{value}'"
+            else:
+                attr_str = f'{key}="{value}"'
+            attrs_str_parts.append(attr_str)
+        attrs_str = ' '.join(attrs_str_parts)
+        return f" {attrs_str}" if attrs_str else ""
+    def convert_element(self, element,  # Element dictionary to convert
+                        indent_level  # Current indentation level
+                        ):
+        if element.get("type") == STRING__SCHEMA_TEXT:
+            return element.get("data", "")
+        tag = element.get("tag")
+        attrs = element.get("attrs", {})
+        nodes = element.get(STRING__SCHEMA_NODES, [])
+        if not tag:  # Safety check
+            return ""
+        attrs_str = self.convert_attrs(attrs)
+        indent = "    " * indent_level
+        # Special handling for void elements
+        if tag in self.self_closing_tags:
+            if nodes:  # Void elements shouldn't have content
+                print(f"Warning: void element <{tag}> has child nodes")
+            return f"{indent}<{tag}{attrs_str} />\n"
+        # Start building the HTML
+        html = f"{indent}<{tag}{attrs_str}>"
+        # Analyze content type
+        has_text_nodes = any(node.get("type") == STRING__SCHEMA_TEXT for node in nodes)
+        has_element_nodes = any(node.get("type") != STRING__SCHEMA_TEXT for node in nodes)
+        # Determine formatting strategy
+        if not nodes:  # Empty element
+            html += f"</{tag}>\n"
+        elif has_element_nodes and not has_text_nodes:  # Only element children
+            html += "\n"
+            html += self.convert_children(nodes, indent_level + 1)
+            html += f"{indent}</{tag}>\n"
+        elif has_text_nodes and not has_element_nodes:  # Only text content
+            html += self.convert_children(nodes, indent_level + 1)
+            html += f"</{tag}>\n"
+        else:  # Mixed content
+            # For mixed content, don't add extra formatting
+            for node in nodes:
+                if node.get("type") == STRING__SCHEMA_TEXT:
+                    html += node.get("data", "")
+                else:
+                    # Recursively convert child elements with no indentation
+                    child_html = self.convert_element(node, 0)
+                    # Remove the trailing newline from child elements in mixed content
+                    if child_html.endswith('\n'):
+                        child_html = child_html[:-1]
+                    html += child_html
+            html += f"</{tag}>\n"
+        return html
+    def convert_children(self, nodes,  # List of child nodes
+                         indent_level  # Current indentation level
+                         ):
+        html = ""
+        for node in nodes:
+            html += self.convert_element(node, indent_level)
+        return html

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

@@ -0,0 +1,49 @@
+from typing                                                         import Dict, 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, position=-1)                                # Root has position -1
+        return Schema__Html_Document(root_node=root_node)
+    def parse_node(self, target: Dict[str, Any], position: int) -> Schema__Html_Node:   # Parse a node and separate child nodes from text nodes with positions
+        if target.get('type') == STRING__SCHEMA_TEXT:                                   # This shouldn't happen at this level since we're parsing element nodes
+            raise ValueError("Unexpected text node at element level")
+        child_nodes = []                                                                # Create lists for child nodes and text nodes
+        text_nodes  = []
+        nodes_list = target.get(STRING__SCHEMA_NODES, [])                               # Process all nodes and assign positions
+        for idx, node in enumerate(nodes_list):
+            if node.get('type') == STRING__SCHEMA_TEXT:                                 # Create text node with position
+                text_node = Schema__Html_Node__Data(data     = node.get('data', '')              ,
+                                                    type     = Schema__Html_Node__Data__Type.TEXT,
+                                                    position = idx                               )
+                text_nodes.append(text_node)
+            else:
+                child_node = self.parse_node(node, position=idx)                        # Create element node with position
+                child_nodes.append(child_node)
+        return Schema__Html_Node(attrs       = target.get('attrs', {}),                 # Create the element node with separated lists
+                                 child_nodes = child_nodes            ,
+                                 text_nodes  = text_nodes             ,
+                                 tag         = target.get('tag'  , ''),
+                                 position    = position               )

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

@@ -0,0 +1,147 @@
+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")
+        if tag_name == 'html':                                  # Handle special tag types with dedicated conversion methods
+            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
+        node_positions = []                                                     # Create node lists with position tracking
+        for idx, node in enumerate(nodes):                                      # Process all nodes and track their positions
+            if node.get("type") == STRING__SCHEMA_TEXT:
+                text_obj = Tag__Text(node.get("data", ""))                      # Create text node with position info
+                node_positions.append((idx, 'text', text_obj))
+            else:
+                child_tag = self.convert_to__tag(Tag__Base, node, tag_indent)   # Create element node
+                node_positions.append((idx, 'element', child_tag))
+        node_positions.sort(key=lambda x: x[0])                                 # Sort by position (though they should already be in order)
+        inner_html = ""                                                         # Collect consecutive text nodes at the beginning for inner_html
+        first_element_idx = None
+        for idx, (pos, node_type, node_obj) in enumerate(node_positions):
+            if node_type == 'element':
+                first_element_idx = idx
+                break
+            else:
+                inner_html += node_obj.data
+        if first_element_idx is None:                                                           # If all nodes are text, use them all as inner_html
+            inner_html = "".join(n[2].data for n in node_positions if n[1] == 'text')
+            elements = []
+        else:
+            inner_html = "".join(n[2].data for i, n in enumerate(node_positions)                # Only use text before first element as inner_html
+                               if n[1] == 'text' and i < first_element_idx)
+            elements = [n[2] for i, n in enumerate(node_positions) if i >= first_element_idx]   # All nodes go into elements (including remaining text nodes)
+        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)
+        tag.elements = elements
+        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':
+                tag_head.title = self.collect_inner_text(node)                                  # Extract title text from text node nodes
+            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':
+                style_element = self.convert_to__tag(Tag__Base, node, head_indent)              # For style tags, collect the CSS content from text nodes
+                tag_head.elements.append(style_element)
+            else:
+                tag_head.elements.append(self.convert_to__tag(Tag__Base, node, head_indent))    # Handle any other head elements
+        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)
+        head_found = False                                                      # Initialize head and body if not found
+        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:
+                print(f'Unexpected child of html tag: {tag_name}')                          # Log unexpected child elements of html
+        if not head_found:                                                                  # Handle missing head or body (required for valid HTML structure)
+            tag_html.head = Tag__Head(indent=tag_html.indent + 1)
+        if not body_found:
+            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.68.0/osbot_utils/helpers/html/Html_Document__To__Html_Dict.py ADDED Viewed

@@ -0,0 +1,44 @@
+from typing                                                     import Dict, Any, List, Union
+from osbot_utils.helpers.html.Html__To__Html_Dict               import STRING__SCHEMA_TEXT, STRING__SCHEMA_NODES, STRING__SCHEMA_TAG, STRING__SCHEMA_ATTRS
+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.type_safe.Type_Safe                            import Type_Safe
+class Html_Document__To__Html_Dict(Type_Safe):
+    html__document : Schema__Html_Document = None
+    html__dict     : dict                  = None
+    def convert(self) -> dict:                                                  # Convert Schema__Html_Document back to html dict format
+        if not self.html__document:
+            raise ValueError("No document to convert")
+        self.html__dict = self.node_to_dict(self.html__document.root_node)
+        return self.html__dict
+    def node_to_dict(self, node: Schema__Html_Node) -> Dict[str, Any]:          # Convert a Schema__Html_Node back to dict format, merging child and text nodes by position
+        result = {  STRING__SCHEMA_TAG   : node.tag,                # Create the basic dict structure
+                    STRING__SCHEMA_ATTRS : node.attrs,
+                    STRING__SCHEMA_NODES : []}
+        all_nodes = []                                              # Merge child_nodes and text_nodes back together based on position
+        for child in node.child_nodes:                              # Add child nodes with their positions
+            all_nodes.append((child.position, 'child', child))
+        for text in node.text_nodes:                                # Add text nodes with their positions
+            all_nodes.append((text.position, 'text', text))
+        all_nodes.sort(key=lambda x: x[0])                          # Sort by position
+        for position, node_type, node_obj in all_nodes:             # Build the nodes list in the correct order
+            if node_type == 'text':
+                text_dict = { 'type': STRING__SCHEMA_TEXT,          # Convert text node to dict
+                              'data': node_obj.data      }
+                result[STRING__SCHEMA_NODES].append(text_dict)
+            else:
+                child_dict = self.node_to_dict(node_obj)            # Recursively convert child node
+                result[STRING__SCHEMA_NODES].append(child_dict)
+        return result

{osbot_utils-2.67.0 → osbot_utils-2.68.0}/osbot_utils/helpers/html/Html__To__Html_Dict.py RENAMED Viewed

@@ -1,8 +1,11 @@
 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_ATTRS   = 'attrs'
 STRING__SCHEMA_NODES   = 'nodes'
+STRING__SCHEMA_TEXT    = 'TEXT'
+STRING__SCHEMA_TAG     = 'tag'
 STRING__DATA_TEXT      = f'{STRING__SCHEMA_TEXT}:'

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

@@ -0,0 +1,12 @@
+from typing                                                   import 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, str           ]                   # HTML attributes (e.g., {'class': 'container'})
+    child_nodes : List['Schema__Html_Node']                   # Element nodes only
+    text_nodes  : List[Schema__Html_Node__Data]               # Text nodes only
+    tag         : str                                         # HTML tag name (e.g., 'div', 'meta', 'title')
+    position    : int = -1                                    # Position in parent's nodes list (-1 for root)

{osbot_utils-2.67.0 → osbot_utils-2.68.0}/osbot_utils/helpers/html/schemas/Schema__Html_Node__Data.py RENAMED Viewed

@@ -4,3 +4,4 @@ from osbot_utils.type_safe.Type_Safe                                import Type_
 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
+    position : int                                                                   # Position in parent's nodes list

{osbot_utils-2.67.0 → osbot_utils-2.68.0}/osbot_utils/type_safe/steps/Type_Safe__Step__Class_Kwargs.py RENAMED Viewed

@@ -6,8 +6,6 @@ from osbot_utils.type_safe.shared.Type_Safe__Shared__Variables   import IMMUTABL
 from osbot_utils.type_safe.shared.Type_Safe__Validation          import type_safe_validation
 from osbot_utils.type_safe.steps.Type_Safe__Step__Default_Value  import type_safe_step_default_value
 class Type_Safe__Step__Class_Kwargs:                                                     # Handles class-level keyword arguments processing
     type_safe_cache : Type_Safe__Cache                                                   # Cache component reference

{osbot_utils-2.67.0 → osbot_utils-2.68.0}/osbot_utils/type_safe/steps/Type_Safe__Step__From_Json.py RENAMED Viewed

@@ -26,7 +26,7 @@ if sys.version_info < (3, 8):                                           # pragma
         else:
             return ()
 else:
-    from typing import get_args, Any
+    from typing import get_args, Any, ForwardRef
 class Type_Safe__Step__From_Json:
@@ -83,6 +83,10 @@ class Type_Safe__Step__From_Json:
                             expected_type        = get_args(attribute_annotation)[0]                            # get the first arg (which is the type)
                             type_safe_list       = Type_Safe__List(expected_type)                               # create a new instance of Type_Safe__List
                             if value:
+                                if isinstance(expected_type, ForwardRef):                                       # Check if it's a self-reference
+                                    forward_name = expected_type.__forward_arg__
+                                    if forward_name == _self.__class__.__name__:
+                                        expected_type = _self.__class__
                                 for item in value:                                                                  # next we need to convert all items (to make sure they all match the type)
                                     if type(item) is dict:
                                         new_item = expected_type(**item)                                                # create new object

{osbot_utils-2.67.0 → osbot_utils-2.68.0}/osbot_utils/type_safe/steps/Type_Safe__Step__Init.py RENAMED Viewed

@@ -1,4 +1,5 @@
 from enum                                                       import EnumMeta
+from typing                                                     import ForwardRef
 from osbot_utils.type_safe.shared.Type_Safe__Annotations        import type_safe_annotations
 from osbot_utils.type_safe.steps.Type_Safe__Step__Default_Value import type_safe_step_default_value, get_args
@@ -27,7 +28,7 @@ class Type_Safe__Step__Init:
                 raise ValueError(f"{__self.__class__.__name__} has no attribute '{key}' and cannot be assigned the value '{value}'. "
                                  f"Use {__self.__class__.__name__}.__default_kwargs__() see what attributes are available") from None
-    def convert_value_to_type_safe_objects(self, __self, key, value):
+    def convert_value_to_type_safe_objects(self, __self, key, value):                                # todo: see if we should use _self here (like in Type_Safe__Step__From_Json, or vice versa)
         annotation = type_safe_annotations.obj_attribute_annotation(__self, key)
         if annotation:
             if isinstance(annotation, EnumMeta) and type(value) is str:
@@ -47,6 +48,10 @@ class Type_Safe__Step__Init:
                 elif origin is list and isinstance(value, list):
                     from osbot_utils.type_safe.Type_Safe__List import Type_Safe__List
                     item_type = get_args(annotation)[0]
+                    if isinstance(item_type, ForwardRef):
+                        forward_name = item_type.__forward_arg__
+                        if forward_name == __self.__class__.__name__:
+                            item_type = __self.__class__
                     type_safe_list = Type_Safe__List(expected_type=item_type)
                     for item in value:
                         type_safe_list.append(item)

osbot_utils-2.68.0/osbot_utils/version ADDED Viewed

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

{osbot_utils-2.67.0 → osbot_utils-2.68.0}/pyproject.toml RENAMED Viewed

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

osbot_utils-2.67.0/osbot_utils/helpers/html/Html_Dict__To__Html.py DELETED Viewed

@@ -1,97 +0,0 @@
-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.67.0/osbot_utils/helpers/html/Html_Dict__To__Html_Document.py DELETED Viewed

@@ -1,37 +0,0 @@
-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.67.0__tar.gz → 2.68.0__tar.gz

osbot-utils 2.67.0tar.gz → 2.68.0tar.gz