PyPI - osbot-utils - Versions diffs - 2.67.0__py3-none-any.whl → 2.69.0__py3-none-any.whl - Mend

osbot-utils 2.67.0py3-none-any.whl → 2.69.0py3-none-any.whl

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 (18) hide show

osbot_utils/helpers/html/Html_Dict__To__Html.py CHANGED Viewed

@@ -1,97 +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_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 __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 ""
-    def convert(self):
         html = self.convert_element(self.root, 0)
-        if self.include_doctype:
+        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):
-        attrs_str_parts = []                                                # List to hold each attribute's string representation
-        for key, value in attrs.items():
-            if value is None:                                               # Handle None values
+    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 '"' 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}"'
+            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}"'                               # If not, simply format the attribute string
+                attr_str = f'{key}="{value}"'
             attrs_str_parts.append(attr_str)
-        attrs_str = ' '.join(attrs_str_parts)                               # Join the parts into the final attributes string
+        attrs_str = ' '.join(attrs_str_parts)
+        return f" {attrs_str}" if attrs_str else ""
-        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
+    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", "")                                  # Return text content directly for text nodes
+            return element.get("data", "")
-        tag   = element.get("tag")
+        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
+        if not tag:  # Safety check
+            return ""
+        attrs_str = self.convert_attrs(attrs)
+        indent = "    " * 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
+        # 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}>"                                # Opening tag with indentation
+        html = f"{indent}<{tag}{attrs_str}>"
-        # 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]
+        # 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)
-        # If there are only element nodes, add a newline after the opening tag
-        if element_nodes and not text_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"
-        # 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
+            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:
-                    # 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
+                    # 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"
-        else:
-            # Empty tag, replace with self-contained format
-            html = f"{indent}<{tag}{attrs_str}></{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/helpers/html/Html_Dict__To__Html_Document.py CHANGED Viewed

@@ -1,4 +1,4 @@
-from typing                                                         import Dict, Union, Any
+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
@@ -6,7 +6,6 @@ from osbot_utils.helpers.html.schemas.Schema__Html_Node__Data       import Schem
 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
@@ -19,19 +18,32 @@ class Html_Dict__To__Html_Document(Type_Safe):
         if not target or not isinstance(target, dict):
             raise ValueError("Invalid HTML dictionary structure")
-        root_node = self.parse_node(target)
+        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]) -> Union[Schema__Html_Node, Schema__Html_Node__Data]:
+    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  = []
-        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))
+        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', {})           ,
-                                     nodes = nodes                              ,
-                                     tag   = target.get('tag', ''))
+        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/helpers/html/Html_Dict__To__Html_Tags.py CHANGED Viewed

@@ -19,19 +19,17 @@ class Html_Dict__To__Html_Tags:
     def convert_element(self, element):
         tag_name = element.get("tag")
-        # Handle special tag types with dedicated conversion methods
-        if tag_name == 'html':
+        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
+            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
+        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."""
+    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:
@@ -39,8 +37,7 @@ class Html_Dict__To__Html_Tags:
         return inner_text
     def convert_to__tag(self, target_tag, element, indent):
-        if element.get("type") == STRING__SCHEMA_TEXT:
-            # Handle text nodes directly
+        if element.get("type") == STRING__SCHEMA_TEXT:          # Handle text nodes directly
             return Tag__Text(element.get("data", ""))
         tag_name   = element.get("tag")
@@ -49,51 +46,68 @@ class Html_Dict__To__Html_Tags:
         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)
+        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)
-        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)
+        inner_html = ""                                                         # Collect consecutive text nodes at the beginning for inner_html
+        first_element_idx = None
-        # 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)
+        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, [])
+        attrs       = element.get("attrs", {})
+        nodes       = element.get(STRING__SCHEMA_NODES, [])
         head_indent = indent + 1
-        tag_head = Tag__Head(indent=head_indent, **attrs)
+        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)
+                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':
-                # For style tags, collect the CSS content from text nodes
-                style_element = self.convert_to__tag(Tag__Base, node, head_indent)
+                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:
-                # Handle any other head elements
-                tag_head.elements.append(self.convert_to__tag(Tag__Base, node, head_indent))
+                tag_head.elements.append(self.convert_to__tag(Tag__Base, node, head_indent))    # Handle any other head elements
         return tag_head
@@ -104,8 +118,7 @@ class Html_Dict__To__Html_Tags:
         tag_html = Tag__Html(attributes=attrs, lang=lang, doc_type=False)
-        # Initialize head and body if not found
-        head_found = False
+        head_found = False                                                      # Initialize head and body if not found
         body_found = False
         for node in nodes:
@@ -118,16 +131,12 @@ class Html_Dict__To__Html_Tags:
                 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}')
+                print(f'Unexpected child of html tag: {tag_name}')                          # Log unexpected child elements of html
-        # Handle missing head or body (required for valid HTML structure)
-        if not head_found:
-            #print("Warning: No head element found, creating empty one")
+        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:
-            #print("Warning: No body element found, creating empty one")
             tag_html.body = Tag__Body(indent=tag_html.indent + 1)
         return tag_html

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/helpers/html/Html__To__Html_Dict.py CHANGED 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/helpers/html/schemas/Schema__Html_Node.py CHANGED Viewed

@@ -1,10 +1,12 @@
-from typing import Union, List, Dict, Optional
+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, Optional[str]]                                     # HTML attributes (e.g., {'class': 'container'}) # todo: see what Safe_Ster we can use for these name attrs
-    nodes    : List[Union['Schema__Html_Node', Schema__Html_Node__Data]]    # Child nodes (recursive structure)
-    tag      : str                                                          # HTML tag name (e.g., 'div', 'meta', 'title')  # todo: see what Safe_Ster we can use for the tag
+    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/helpers/html/schemas/Schema__Html_Node__Data.py CHANGED 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/helpers/llms/builders/LLM_Request__Builder.py CHANGED Viewed

@@ -1,5 +1,6 @@
 from typing                                                                 import Dict, Any, Type
 from osbot_utils.helpers.llms.actions.Type_Safe__Schema_For__LLMs           import Type_Safe__Schema_For__LLMs
+from osbot_utils.helpers.llms.schemas.Safe_Str__LLM__Model_Name             import Safe_Str__LLM__Model_Name
 from osbot_utils.helpers.llms.schemas.Schema__LLM_Request                   import Schema__LLM_Request
 from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Data             import Schema__LLM_Request__Data
 from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Function_Call    import Schema__LLM_Request__Function_Call
@@ -40,14 +41,14 @@ class LLM_Request__Builder(Type_Safe):
         self.llm_request_data.function_call = function_call
         return self
-    def set__model              (self, model   : Safe_Str__Text): self.llm_request_data.model    = model   ; return self
-    def set__platform           (self, platform: Safe_Str__Text): self.llm_request_data.platform = platform; return self
-    def set__provider           (self, provider: Safe_Str__Text): self.llm_request_data.provider = provider; return self
-    def set__model__gpt_4o      (self                          ): return self.set__model('gpt-4o'      )
-    def set__model__gpt_4o_mini (self                          ): return self.set__model('gpt-4o-mini' )
-    def set__model__gpt_4_1     (self                          ): return self.set__model('gpt-4.1'     )
-    def set__model__gpt_4_1_mini(self                          ): return self.set__model('gpt-4.1-mini')
-    def set__model__gpt_4_1_nano(self                          ): return self.set__model('gpt-4.1-nano')
+    def set__model              (self, model   : Safe_Str__LLM__Model_Name): self.llm_request_data.model    = model   ; return self
+    def set__platform           (self, platform: Safe_Str__Text           ): self.llm_request_data.platform = platform; return self
+    def set__provider           (self, provider: Safe_Str__Text           ): self.llm_request_data.provider = provider; return self
+    def set__model__gpt_4o      (self                                     ): return self.set__model('gpt-4o'      )
+    def set__model__gpt_4o_mini (self                                     ): return self.set__model('gpt-4o-mini' )
+    def set__model__gpt_4_1     (self                                     ): return self.set__model('gpt-4.1'     )
+    def set__model__gpt_4_1_mini(self                                     ): return self.set__model('gpt-4.1-mini')
+    def set__model__gpt_4_1_nano(self                                     ): return self.set__model('gpt-4.1-nano')
     @type_safe

osbot_utils/helpers/llms/schemas/Safe_Str__LLM__Model_Name.py ADDED Viewed

@@ -0,0 +1,10 @@
+import re
+from osbot_utils.helpers.safe_str.Safe_Str import Safe_Str
+TYPE_SAFE_STR__LLM__MODEL_NAME__MAX_LENGTH = 256
+TYPE_SAFE_STR__LLM__MODEL_NAME__REGEX      =  r'[^a-zA-Z0-9/_\-.:]'
+class Safe_Str__LLM__Model_Name(Safe_Str):
+    regex      = re.compile(TYPE_SAFE_STR__LLM__MODEL_NAME__REGEX)
+    max_length = TYPE_SAFE_STR__LLM__MODEL_NAME__MAX_LENGTH

osbot_utils/helpers/llms/schemas/Schema__LLM_Request__Data.py CHANGED Viewed

@@ -1,11 +1,12 @@
 from typing                                                                 import List, Optional
+from osbot_utils.helpers.llms.schemas.Safe_Str__LLM__Model_Name             import Safe_Str__LLM__Model_Name
 from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Function_Call    import Schema__LLM_Request__Function_Call
 from osbot_utils.helpers.llms.schemas.Schema__LLM_Request__Message__Content import Schema__LLM_Request__Message__Content
 from osbot_utils.helpers.safe_str.Safe_Str__Text                            import Safe_Str__Text
 from osbot_utils.type_safe.Type_Safe                                        import Type_Safe
 class Schema__LLM_Request__Data(Type_Safe):                                         # Schema for LLM API request data
-    model         : Safe_Str__Text                                                  # LLM model identifier
+    model         : Safe_Str__LLM__Model_Name                                       # LLM model identifier
     platform      : Safe_Str__Text
     provider      : Safe_Str__Text
     messages      : List    [Schema__LLM_Request__Message__Content]                 # Message content entries

osbot_utils/type_safe/steps/Type_Safe__Step__Class_Kwargs.py CHANGED 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/type_safe/steps/Type_Safe__Step__From_Json.py CHANGED 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/type_safe/steps/Type_Safe__Step__Init.py CHANGED 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/version CHANGED Viewed

	@@ -1 +1 @@
1	- v2.67.0
1	+ v2.69.0

{osbot_utils-2.67.0.dist-info → osbot_utils-2.69.0.dist-info}/METADATA RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.67.0
+Version: 2.69.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.69.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.dist-info → osbot_utils-2.69.0.dist-info}/RECORD RENAMED Viewed

@@ -181,10 +181,11 @@ osbot_utils/helpers/generators/Model__Generator_State.py,sha256=cS9tigdBIAvexip2
 osbot_utils/helpers/generators/Model__Generator_Target.py,sha256=Sh_1J0_RYOBYKqg19DP4_e2MPx6CHCzydkA56F8SjRs,816
 osbot_utils/helpers/generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/html/CSS_Dict__To__Css.py,sha256=ZDIVfFCYO4UQsRprbx9vCosFqrnHizZUH-JgP5oZcuA,1102
-osbot_utils/helpers/html/Html_Dict__To__Html.py,sha256=jLizQHHfSLkOkdzbfSyPuHFysUARl9hu-RWhGuUWKWA,4956
-osbot_utils/helpers/html/Html_Dict__To__Html_Document.py,sha256=hpN-3IJjYNly1tcCWp5JuLsE_idawgcYpMpXcwFnqHI,2135
-osbot_utils/helpers/html/Html_Dict__To__Html_Tags.py,sha256=MfXW-tfTBA7DiGJfUX1HB4-Y1F1kxdIhTyglYHUblOs,5425
-osbot_utils/helpers/html/Html__To__Html_Dict.py,sha256=VDaTOkrsidhLUj2Uuj7YdP0VYlLm6inFaRKybeC8ppg,4340
+osbot_utils/helpers/html/Html_Dict__To__Html.py,sha256=Xa5J1elZBK1a5ae75ckenTtNOZs1XX87s1qmu73JatE,4547
+osbot_utils/helpers/html/Html_Dict__To__Html_Document.py,sha256=mUi3U5zJwFC7iXQ-kT8uWhMkkK9ZIUKHukdSOuIBCfc,3132
+osbot_utils/helpers/html/Html_Dict__To__Html_Tags.py,sha256=46-5aeCnx5LgegKpN227xtx21WcQOB_7gN9NCcxYoA0,7019
+osbot_utils/helpers/html/Html_Document__To__Html_Dict.py,sha256=D4tiZaPpyUXKsNURejvBXNW3BFX3dQAm65bLBkD0FhY,2509
+osbot_utils/helpers/html/Html__To__Html_Dict.py,sha256=GJ4NZZ5lMFr2u0hfTpqPOMXmKLyinjCeqypg3JjME8c,4405
 osbot_utils/helpers/html/Html__To__Html_Document.py,sha256=xVbIT3TaxZPt4cz3lO4WvSru7FyWI1p36qdXp6HGC8o,886
 osbot_utils/helpers/html/Html__To__Html_Tag.py,sha256=Qz6he08DwfYkYM_krt_FCVtEWgw6_9bs5j5CoC1FCQQ,566
 osbot_utils/helpers/html/Tag__Base.py,sha256=geD7TpA3lHrSiaoLsViH2rcjrqZkMxNpDOhLx3HYbSk,4470
@@ -199,15 +200,15 @@ osbot_utils/helpers/html/Tag__Style.py,sha256=wRZ8DN1HVCtrnL4Flz82oByqJOy8Th40Eh
 osbot_utils/helpers/html/Tag__Text.py,sha256=Pqf96QGwX9wdGqlwBvWYHWz9Qqi-oZrkgEzHQm6LzdY,241
 osbot_utils/helpers/html/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/html/schemas/Schema__Html_Document.py,sha256=227IP9kfQ7FH7bhd-LsPsppPo-mhwC58BcGYWsy0WwQ,381
-osbot_utils/helpers/html/schemas/Schema__Html_Node.py,sha256=dz_LI9xzoz6_Gfh6aQbGBeN3IHZLlWVjESIegNz9vxY,728
-osbot_utils/helpers/html/schemas/Schema__Html_Node__Data.py,sha256=T0S-MF-aw91fZCoU0vkDH0Ni_4oAyiXGdIMsHXdt4fs,449
+osbot_utils/helpers/html/schemas/Schema__Html_Node.py,sha256=iMGClwil99_KoeLuft53DQLu9Jw-PCqRjBXpfInd7rM,794
+osbot_utils/helpers/html/schemas/Schema__Html_Node__Data.py,sha256=GiAZY5mO3DNasUO_oNM4ndTvRU2VpjPxOi7kYzu2DHE,568
 osbot_utils/helpers/html/schemas/Schema__Html_Node__Data__Type.py,sha256=mbYivcm6BfN5-oeCyl6gjbnSKs_b_t-G2H1rpSK6nUY,90
 osbot_utils/helpers/html/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/llms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/llms/actions/LLM_Request__Execute.py,sha256=IsC5gzQXG__j5M2dSWVCmV77Kf133pKbZRvbiQyeihU,2453
 osbot_utils/helpers/llms/actions/Type_Safe__Schema_For__LLMs.py,sha256=em9RoSZqSSo6BQBZvEKH8Qv8f8f8oubNpy0LIDsak-E,12024
 osbot_utils/helpers/llms/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/helpers/llms/builders/LLM_Request__Builder.py,sha256=2Zp4Ka4q2XcZNUuR47kP7iyhfLsY2A_rxOME3i6olgE,3811
+osbot_utils/helpers/llms/builders/LLM_Request__Builder.py,sha256=d9TnJmA1KbEypvCdgFXWcg684n-TGIrumxigsTOMECE,4008
 osbot_utils/helpers/llms/builders/LLM_Request__Builder__Open_AI.py,sha256=JwyPDeBUQd70Ltm801y5qvS883IIC7TcfG04D3LWdGI,3430
 osbot_utils/helpers/llms/builders/LLM_Request__Factory.py,sha256=bpFXVTKpalBL7ZONjaHU5c0-2Rwzzd2vgdD1FpYxfGw,6291
 osbot_utils/helpers/llms/builders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -221,9 +222,10 @@ osbot_utils/helpers/llms/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 osbot_utils/helpers/llms/platforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/llms/platforms/open_ai/API__LLM__Open_AI.py,sha256=Yyy2ZnIS6CfxXepP9pZNsOYx02d-5EnK1IFeFf8myyk,2148
 osbot_utils/helpers/llms/platforms/open_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osbot_utils/helpers/llms/schemas/Safe_Str__LLM__Model_Name.py,sha256=AKLfBv65ELl6XvSsLKMVS-y9LefSVNf8GNrEWKVd_TY,358
 osbot_utils/helpers/llms/schemas/Schema__LLM_Cache__Index.py,sha256=12dUUSFhWRZvqEkNivqajqMPApPWhfSI7jWnHyBuxNw,717
 osbot_utils/helpers/llms/schemas/Schema__LLM_Request.py,sha256=UUiqZQ5mj16SPdlzef7_j3myLaKKCZdAUjsWUJnK1Ag,378
-osbot_utils/helpers/llms/schemas/Schema__LLM_Request__Data.py,sha256=EpII6ZMkWACkoHYn-TNowppbIskyoaCovefPA5Q5qtA,1380
+osbot_utils/helpers/llms/schemas/Schema__LLM_Request__Data.py,sha256=oLrvmngkDVX2KB2gVR1DwvJQcxWMbBxomjs_IBFQtzc,1489
 osbot_utils/helpers/llms/schemas/Schema__LLM_Request__Function_Call.py,sha256=VJgWi4aK-DJmuJvfY2qZUZuLkrLlmu5lgyzxZrrp3hM,440
 osbot_utils/helpers/llms/schemas/Schema__LLM_Request__Message__Content.py,sha256=nl-16yz4G_72ViACKE9CvGStrKxw2Gm_JcaU8wVcJXI,521
 osbot_utils/helpers/llms/schemas/Schema__LLM_Request__Message__Role.py,sha256=T99w0cRrDPXQqPT-Nw7_14tMr4vKpUlhw74UJZL6w6w,168
@@ -393,11 +395,11 @@ osbot_utils/type_safe/shared/Type_Safe__Raise_Exception.py,sha256=TMO4uqPLzie79k
 osbot_utils/type_safe/shared/Type_Safe__Shared__Variables.py,sha256=SuZGl9LryQX6IpOE0I_lbzClT-h17UNylC__-M8ltTY,129
 osbot_utils/type_safe/shared/Type_Safe__Validation.py,sha256=1XvbWJmRfyqBcdOTuYZ5fiItyMF0ttSPFnWjqZTGbYE,19542
 osbot_utils/type_safe/shared/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/type_safe/steps/Type_Safe__Step__Class_Kwargs.py,sha256=snoyJKvZ1crgF2fp0zexwNPnV_E63RfyRIsMAZdrKNY,6995
+osbot_utils/type_safe/steps/Type_Safe__Step__Class_Kwargs.py,sha256=hlKJi2hVFntOoQJNlcyDk4JdnkZfEmnIhQNA0c8keCs,6993
 osbot_utils/type_safe/steps/Type_Safe__Step__Default_Kwargs.py,sha256=tzKXDUc0HVP5QvCWsmcPuuZodNvQZ9FeMDNI2x00Ngw,1943
 osbot_utils/type_safe/steps/Type_Safe__Step__Default_Value.py,sha256=b5vsgM8eg9yq2KM0wRMntVHma6OhN_HnU76LxhEIpoA,4483
-osbot_utils/type_safe/steps/Type_Safe__Step__From_Json.py,sha256=AguNcZwKKnyNY87bSAF1xLwYW5h_IDfUad70QqIiK3I,14622
-osbot_utils/type_safe/steps/Type_Safe__Step__Init.py,sha256=wBdShMavx8Ja5IACyW8dP3_fq_iqrMp8HHziOqjgxqU,4483
+osbot_utils/type_safe/steps/Type_Safe__Step__From_Json.py,sha256=jeRj7dNDObDv_wz0EELX_hTprVJ2Ddi_UG3_ZZUL-74,15013
+osbot_utils/type_safe/steps/Type_Safe__Step__Init.py,sha256=6TKpIiwuYcQRUS5Wc0j_y0oToKBah2yc0q8jcDwEZ7U,4938
 osbot_utils/type_safe/steps/Type_Safe__Step__Set_Attr.py,sha256=k7GX3q0ps4R1Z3w5JMFHB0w19zVXtO1VS11wpFVI19o,6680
 osbot_utils/type_safe/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/validators/Type_Safe__Validator.py,sha256=cJIPSBarjV716SZUOLvz7Mthjk-aUYKUQtRDtKUBmN4,779
@@ -432,8 +434,8 @@ osbot_utils/utils/Toml.py,sha256=Rxl8gx7mni5CvBAK-Ai02EKw-GwtJdd3yeHT2kMloik,166
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
 osbot_utils/utils/Zip.py,sha256=pR6sKliUY0KZXmqNzKY2frfW-YVQEVbLKiyqQX_lc-8,14052
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=c6L9xxoyMql0emsdEbUgj7ng8gzCDcVgYkJG0iDe484,8
-osbot_utils-2.67.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.67.0.dist-info/METADATA,sha256=bemaemZYec52lrfkkWRpf9HbtcwERuynDCoY6TFH-Vw,1329
-osbot_utils-2.67.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.67.0.dist-info/RECORD,,
+osbot_utils/version,sha256=mmT3TZTEYCy0jjpssvKXIUrmVMPAJu7HXXH98D1g9XE,8
+osbot_utils-2.69.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.69.0.dist-info/METADATA,sha256=GFekKv0EI34E7oUrhdWAUcTZQh0NWsvuh76sFgazH84,1329
+osbot_utils-2.69.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.69.0.dist-info/RECORD,,

{osbot_utils-2.67.0.dist-info → osbot_utils-2.69.0.dist-info}/LICENSE RENAMED Viewed

File without changes

{osbot_utils-2.67.0.dist-info → osbot_utils-2.69.0.dist-info}/WHEEL RENAMED Viewed

File without changes

osbot-utils 2.67.0__py3-none-any.whl → 2.69.0__py3-none-any.whl

osbot-utils 2.67.0py3-none-any.whl → 2.69.0py3-none-any.whl