sapiopycommons 2025.6.6a559__py3-none-any.whl → 2025.6.10a560__py3-none-any.whl

sapiopycommons/chem/IndigoMolecules.py

@@ -10,9 +10,36 @@ indigo.setOption("render-stereo-style", "ext")
 indigo.setOption("aromaticity-model", "generic")
 indigo.setOption("render-coloring", True)
 indigo.setOption("molfile-saving-mode", "3000")
+indigo.setOption("dearomatize-verification", False)
 indigo_inchi = IndigoInchi(indigo)
 
 
+def get_aromatic_dearomatic_forms(m: IndigoObject):
+    """
+    Get the aromatic and dearomatic forms of the molecule. Retain the original form if it's not inversible.
+    Inversible: after aromatic-dearomatic-aromatic transformation, the molecule is the same as the first aromatic transformation.
+    :param m: molecule from indigo.
+    :return: pair of indigo objects, first is aromatic, second is dearomatic.
+    """
+    try:
+        aromatic_reaction = m.clone()
+        aromatic_reaction.aromatize()
+        dearomatic_reaction = aromatic_reaction.clone()
+        dearomatic_reaction.dearomatize()
+        second_aromatic_reaction = dearomatic_reaction.clone()
+        second_aromatic_reaction.aromatize()
+        match = indigo.exactMatch(aromatic_reaction, second_aromatic_reaction)
+        if match:
+            return aromatic_reaction, dearomatic_reaction
+        else:
+            return m, dearomatic_reaction
+    except (Exception):
+        # If aromatization then following deromatization fails, we just skip it.
+        dearomatic_reaction = m.clone()
+        dearomatic_reaction.dearomatize()
+        return m, dearomatic_reaction
+
+
 # Function to process dative bonds in a molecule
 # Returns True if at least one dative bond (_BOND_COORDINATION) was removed
 def remove_dative_bonds_in_mol(molecule: IndigoObject) -> bool:
@@ -51,7 +78,8 @@ def remove_dative_in_reaction(reaction: IndigoObject) -> bool:
     :param reaction: The reaction to remove dative bonds.
     :return: Whether there are any dative bonds in the reaction that were removed.
     """
-    reactant_dative_removed: bool = any(remove_dative_bonds_in_mol(reactant) for reactant in reaction.iterateReactants())
+    reactant_dative_removed: bool = any(
+        remove_dative_bonds_in_mol(reactant) for reactant in reaction.iterateReactants())
     product_dative_removed: bool = any(remove_dative_bonds_in_mol(product) for product in reaction.iterateProducts())
     return reactant_dative_removed or product_dative_removed
 

sapiopycommons/chem/Molecules.py

@@ -1,6 +1,6 @@
 # Author Yechen Qiao
 # Common Molecule Utilities for Molecule Transfers with Sapio
-
+from indigo import IndigoObject
 from rdkit import Chem
 from rdkit.Chem import Crippen, MolToInchi
 from rdkit.Chem import Descriptors
@@ -10,7 +10,7 @@ from rdkit.Chem.MolStandardize import rdMolStandardize
 from rdkit.Chem.SaltRemover import SaltRemover
 from rdkit.Chem.rdchem import Mol, RWMol, Bond
 
-from sapiopycommons.chem.IndigoMolecules import indigo, renderer, indigo_inchi
+from sapiopycommons.chem.IndigoMolecules import indigo, renderer, indigo_inchi, get_aromatic_dearomatic_forms
 
 metal_disconnector = rdMolStandardize.MetalDisconnector()
 tautomer_params = Chem.MolStandardize.rdMolStandardize.CleanupParameters()
@@ -247,7 +247,7 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers=False,
         molecule["image"] = None
     # We need to test the INCHI can be loaded back to indigo.
     indigo_mol = indigo.loadMolecule(molBlock)
-    indigo_mol.aromatize()
+    indigo_mol = get_aromatic_dearomatic_forms(indigo_mol)[0]  # Get the aromatic form of the molecule.
     if enhanced_stereo:
         # Remove enhanced stereo layer when generating InChI as the stereo hash is generated separately for reg.
         Chem.CanonicalizeEnhancedStereo(inchi_mol)

sapiopycommons/general/html_formatter.py

@@ -0,0 +1,456 @@
+from __future__ import annotations
+
+import re
+from typing import Final
+
+
+class HtmlFormatter:
+    """
+    A class for formatting text in HTML with tag classes supported by the client.
+    """
+    TIMESTAMP_TEXT__CSS_CLASS_NAME: Final[str] = "timestamp-text"
+    HEADER_1_TEXT__CSS_CLASS_NAME: Final[str] = "header1-text"
+    HEADER_2_TEXT__CSS_CLASS_NAME: Final[str] = "header2-text"
+    HEADER_3_TEXT__CSS_CLASS_NAME: Final[str] = "header3-text"
+    BODY_TEXT__CSS_CLASS_NAME: Final[str] = "body-text"
+    CAPTION_TEXT__CSS_CLASS_NAME: Final[str] = "caption-text"
+
+    @staticmethod
+    def timestamp(text: str) -> str:
+        """
+        Given a text string, return that same text string HTML formatted using the timestamp CSS class.
+
+        :param text: The text to format.
+        :return: The HTML formatted text.
+        """
+        return f'<span class="{HtmlFormatter.TIMESTAMP_TEXT__CSS_CLASS_NAME}">{text}</span>'
+
+    @staticmethod
+    def header_1(text: str) -> str:
+        """
+        Given a text string, return that same text string HTML formatted using the header 1 CSS class.
+
+        :param text: The text to format.
+        :return: The HTML formatted text.
+        """
+        return f'<span class="{HtmlFormatter.HEADER_1_TEXT__CSS_CLASS_NAME}">{text}</span>'
+
+    @staticmethod
+    def header_2(text: str) -> str:
+        """
+        Given a text string, return that same text string HTML formatted using the header 2 CSS class.
+
+        :param text: The text to format.
+        :return: The HTML formatted text.
+        """
+        return f'<span class="{HtmlFormatter.HEADER_2_TEXT__CSS_CLASS_NAME}">{text}</span>'
+
+    @staticmethod
+    def header_3(text: str) -> str:
+        """
+        Given a text string, return that same text string HTML formatted using the header 3 CSS class.
+
+        :param text: The text to format.
+        :return: The HTML formatted text.
+        """
+        return f'<span class="{HtmlFormatter.HEADER_3_TEXT__CSS_CLASS_NAME}">{text}</span>'
+
+    @staticmethod
+    def body(text: str) -> str:
+        """
+        Given a text string, return that same text string HTML formatted using the body text CSS class.
+
+        :param text: The text to format.
+        :return: The HTML formatted text.
+        """
+        return f'<span class="{HtmlFormatter.BODY_TEXT__CSS_CLASS_NAME}">{text}</span>'
+
+    @staticmethod
+    def caption(text: str) -> str:
+        """
+        Given a text string, return that same text string HTML formatted using the caption text CSS class.
+
+        :param text: The text to format.
+        :return: The HTML formatted text.
+        """
+        return f'<span class="{HtmlFormatter.CAPTION_TEXT__CSS_CLASS_NAME}">{text}</span>'
+
+    @staticmethod
+    def replace_newlines(text: str) -> str:
+        """
+        Given a text string, return that same text string HTML formatted with newlines replaced by HTML line breaks.
+
+        :param text: The text to format.
+        :return: The HTML formatted text.
+        """
+        return re.sub("\r?\n", "<br>", text)
+
+    @staticmethod
+    def scrub_html(text: str) -> str:
+        """
+        Given a string that contains HTML, return that same string with all HTML removed.
+
+        :param text: The HTML string to scrub.
+        :return: The scrubbed text.
+        """
+        if not text:
+            return ""
+
+        from bs4 import BeautifulSoup
+        return BeautifulSoup(text, "html.parser").get_text()
+
+    @staticmethod
+    def scrub_markdown(text: str) -> str:
+        """
+        Given a string that contains markdown, return that same string with all markdown removed.
+
+        :param text: The markdown string to scrub.
+        :return: The scrubbed text.
+        """
+        if not text:
+            return ""
+
+        # --- Remove Headers ---
+        # Level 1-6 headers (# to ######)
+        text = re.sub(r"^#{1,6}\s*(.*)$", r"\1", text, flags=re.MULTILINE).strip()
+
+        # --- Remove Emphasis ---
+        # Bold (**text** or __text__)
+        text = re.sub(r"\*\*(.*?)\*\*", r"\1", text)
+        text = re.sub(r"__(.*?)__", r"\1", text)
+
+        # Italic (*text* or _text_)
+        text = re.sub(r"\*(.*?)\*", r"\1", text)
+        text = re.sub(r"_(.*?)_", r"\1", text)
+
+        # --- Remove Strikethrough ---
+        # Strikethrough (~~text~~)
+        text = re.sub(r"~~(.*?)~~", r"\1", text)
+
+        # --- Remove Links ---
+        # Links ([text](url))
+        text = re.sub(r"\[(.*?)]\((.*?)\)", r"\1", text)
+
+        # --- Remove Images ---
+        # Images (![alt text](url))
+        text = re.sub(r"!\\[(.*?)\\]\\((.*?)\\)", "", text)  # remove the entire image tag
+
+        # --- Remove Code ---
+        # Inline code (`code`)
+        text = re.sub(r"`(.*?)`", r"\1", text)
+
+        # Code blocks (```code```)
+        text = re.sub(r"```.*?```", "", text, flags=re.DOTALL)  # multiline code blocks
+
+        # --- Remove Lists ---
+        # Unordered lists (* item, - item, + item)
+        text = re.sub(r"(?m)^[*\-+]\s+", "", text)
+
+        # Ordered lists (1. item)
+        text = re.sub(r"(?m)^\d+\.\s+", "", text)
+
+        # --- Remove Blockquotes ---
+        # Blockquotes (> text)
+        text = re.sub(r"(?m)^>\s+", "", text)
+
+        # --- Remove Horizontal Rules ---
+        # Horizontal rules (---, ***, ___)
+        text = re.sub(r"(?m)^[-_*]{3,}\s*$", "", text)  # Remove horizontal rules
+
+        # --- Remove HTML tags (basic)---
+        #  This is a very simple HTML tag removal, it does not handle nested tags or attributes properly.
+        text = re.sub(r"<[^>]*>", "", text)
+
+        # --- Remove escaped characters ---
+        text = re.sub(r"\\([!\"#$%&'()*+,./:;<=>?@\\[]^_`{|}~-])", r"\1", text)
+
+        return text
+
+    @staticmethod
+    def convert_markdown_to_html(text: str) -> str:
+        """
+        Given a markdown string, convert it to HTML and return the HTML string.
+
+        :param text: The markdown string to convert.
+        :return: The HTML string.
+        """
+        if not text:
+            return ""
+
+        # Replace newlines with break tags and tabs with em spaces.
+        text = text.replace("\r\n", "<br>").replace("\n", "<br>").replace("\t", "&emsp;")
+
+        # Format code blocks to maintain indentation.
+        text = HtmlFormatter.format_code_blocks(text, "<br>")
+
+        # Convert any other markdown to HTML.
+        text = HtmlFormatter._convert_markdown_by_line(text)
+
+        return text
+
+    @staticmethod
+    def format_code_blocks(text: str, newline: str = "\n") -> str:
+        """
+        Locate each markdown code block in the given text and format it with HTML code and preformatting tags
+        to maintain indentation and add language-specific syntax highlighting.
+
+        :param text: The text to format.
+        :param newline: The newline character to expect in the input text.
+        :return: The formatted text.
+        """
+        # Extract all the code blocks from the text
+        code_blocks = HtmlFormatter.extract_code_blocks(text, newline)
+        if not code_blocks:
+            return text
+
+        # Iterate through the code blocks, adding them to the text with the <pre><code> </code></pre>
+        # so that indentation is preserved.
+        current_index = 0
+        formatted = []
+        for code_block in code_blocks:
+            formatted.append(text[current_index:code_block.start_index])
+            formatted.append(code_block.to_html())
+            current_index = code_block.end_index
+        # Append the rest of the text after the last code block.
+        formatted.append(text[current_index:])
+        return "".join(formatted)
+
+    @staticmethod
+    def sanitize_code_blocks(text: str, newline: str = "\n") -> str:
+        """
+        Given the input text, remove all code blocks while leaving all other text unchanged.
+        For use in any location where we don't want to display code (because it's scary).
+
+        :param text: The text to sanitize.
+        :param newline: The newline character to expect in the input text.
+        :return: The sanitized text.
+        """
+        code_blocks = HtmlFormatter.extract_code_blocks(text, newline)
+
+        if not code_blocks:
+            return text
+
+        current_index = 0
+        formatted_text = []
+
+        for block in code_blocks:
+            formatted_text.append(text[current_index: block.start_index])
+            current_index = block.end_index
+
+        formatted_text.append(text[current_index:])
+
+        return "".join(formatted_text)
+
+    @staticmethod
+    def extract_code_blocks(text: str, newline: str = "\n") -> list[CodeBlock]:
+        """
+        Extract all code blocks from the given response.
+
+        :param text: The text to extract the code blocks from.
+        :param newline: The newline character to expect in the input text.
+        :return: A list of code blocks.
+        """
+        code: list[CodeBlock] = []
+        current_index = 0
+        while current_index < len(text):
+            code_block = HtmlFormatter.next_code_block(text, current_index, newline)
+            if code_block is None:
+                break
+            code.append(code_block)
+            current_index = code_block.end_index
+        return code
+
+    @staticmethod
+    def next_code_block(text: str, start_index: int, newline: str = "\n") -> CodeBlock | None:
+        """
+        Extract the next code block from the given response, starting at the given index.
+
+        :param text: The text to extract the code block from.
+        :param start_index: The index to start searching for the code block at.
+        :param newline: The newline character to expect in the input text.
+        :return: The extracted code block. Null if no code block is found after the start index.
+        """
+        # Find the start of the next code block.
+        start_tag = text.find("```", start_index)
+        if start_tag == -1:
+            return None
+
+        # Extract the language from the starting tag of the code block.
+        first_line = text.find(newline, start_tag)
+        if first_line == -1:
+            return None
+        language = text[start_tag + 3:first_line].strip()
+        first_line += len(newline)
+
+        # Find the end of the code block.
+        code: str
+        end_tag = text.find("```", first_line)
+        # If there is no end to the code block, just return the rest of the text as a code block.
+        if end_tag == -1:
+            end_tag = len(text)
+            code = text[first_line:end_tag]
+        else:
+            code = text[first_line:end_tag]
+            end_tag += 3
+        return CodeBlock(code, language, start_tag, end_tag)
+
+    @staticmethod
+    def _convert_markdown_by_line(text: str) -> str:
+        """
+        Convert markdown to HTML for each line in the given markdown text.  Line breaks are expected to be represented
+        by break tags already.
+
+        :param text: The markdown text to convert.
+        :return: The HTML text.
+        """
+        html = []
+        lines = text.split("<br>")
+
+        in_unordered_list = False
+        in_ordered_list = False
+
+        for line in lines:
+            # Skip code blocks, as these have already been formatted.
+            # Also skip empty lines.
+            if "</code></pre>" in line or not line.strip():
+                html.append(line + "<br>")
+                continue
+            processed_line = HtmlFormatter._process_line(line.strip())
+
+            # Handle headings
+            if processed_line.startswith("# "):
+                HtmlFormatter._close_lists(html, in_unordered_list, in_ordered_list)
+                in_unordered_list = False
+                in_ordered_list = False
+                html.append(HtmlFormatter.header_1(processed_line[2:].strip()) + "<br>")
+            elif processed_line.startswith("## "):
+                HtmlFormatter._close_lists(html, in_unordered_list, in_ordered_list)
+                in_unordered_list = False
+                in_ordered_list = False
+                html.append(HtmlFormatter.header_2(processed_line[3:].strip()) + "<br>")
+            elif processed_line.startswith("### "):
+                HtmlFormatter._close_lists(html, in_unordered_list, in_ordered_list)
+                in_unordered_list = False
+                in_ordered_list = False
+                html.append(HtmlFormatter.header_3(processed_line[4:].strip()) + "<br>")
+            # Handle unordered lists
+            elif processed_line.startswith("* "):
+                if not in_unordered_list:
+                    HtmlFormatter._close_lists(html, False, in_ordered_list)  # Close any previous ordered list.
+                    in_ordered_list = False
+                    html.append("<ul>")
+                    in_unordered_list = True
+                html.append("<li>" + HtmlFormatter.body(processed_line[2:].strip()) + "</li>")
+            # Handle ordered lists
+            elif re.match(r"^\d+\. .*", processed_line):  # Matches "1. text"
+                if not in_ordered_list:
+                    HtmlFormatter._close_lists(html, in_unordered_list, False)  # Close any previous unordered list.
+                    in_unordered_list = False
+                    html.append("<ol>")
+                    in_ordered_list = True
+                html.append(
+                    "<li>" + HtmlFormatter.body(processed_line[processed_line.find('.') + 2:].strip()) + "</li>")
+
+            # Handle regular paragraphs
+            else:
+                HtmlFormatter._close_lists(html, in_unordered_list, in_ordered_list)
+                in_unordered_list = False
+                in_ordered_list = False
+                html.append(HtmlFormatter.body(processed_line.strip()) + "<br>")
+
+        # Close any open lists at the end
+        HtmlFormatter._close_lists(html, in_unordered_list, in_ordered_list)
+
+        return "".join(html)
+
+    @staticmethod
+    def _close_lists(text: list, in_unordered_list: bool, in_ordered_list: bool):
+        """
+        Close any open unordered or ordered lists in the given HTML string.
+
+        :param text: The HTML string to append to.
+        :param in_unordered_list: Whether an unordered list is currently open.
+        :param in_ordered_list: Whether an ordered list is currently open.
+        """
+        if in_unordered_list:
+            text.append("</ul>")
+        if in_ordered_list:
+            text.append("</ol>")
+
+    @staticmethod
+    def _process_line(line: str) -> str:
+        """
+        Process a single line of markdown text and convert it to HTML.
+
+        :param line: The line of markdown text to process.
+        :return: The HTML formatted line.
+        """
+        # Bold: **text**
+        line = re.sub(r"\*\*(.*?)\*\*", r"<strong>\1</strong>", line)
+
+        # Italic: *text*
+        line = re.sub(r"\*(.*?)\*", r"<em>\1</em>", line)
+
+        # Code: `text`
+        line = re.sub(r"`(.*?)`", r"<code>\1</code>", line)
+
+        return line
+
+
+class CodeBlock:
+    """
+    A class representing a code block extracted from a response.
+    """
+    def __init__(self, code: str, language: str, start_index: int, end_index: int):
+        """
+        :param code: The text of the code block.
+        :param language: The language of the code block.
+        :param start_index: The index of the first character of the code block in the original response.
+        :param end_index: The index after the last character of the code block in the original response.
+        """
+        if code is None:
+            raise ValueError("Code cannot be None")
+        if language is None:
+            language = ""
+        if start_index < 0 or end_index < 0 or start_index > end_index:
+            raise ValueError("Invalid start or end index")
+
+        # Replace em spaces within code blocks with quadruple spaces and break tags with newlines.
+        # Code editors that the code is copy/pasted into might not recognize em spaces as valid indentation,
+        # and the library that adds the language-specific syntax highlighting expects newlines instead of break
+        # tags.
+        if "<br>" in code:
+            code = code.replace("<br>", "\n")
+        if "&emsp;" in code:
+            code = code.replace("&emsp;", "    ")
+        # We don't want mixed whitespace, so replace all tabs with quad spaces.
+        if "\t" in code:
+            code = code.replace("\t", "    ")
+
+        self.code = code
+        self.language = language.strip()
+        self.start_index = start_index
+        self.end_index = end_index
+
+    def to_html(self) -> str:
+        """
+        :return: The HTML representation of this code block.
+        """
+        start_tag: str
+        if self.language:
+            lang_class = f'class="language-{self.language}"'
+            start_tag = f"<pre {lang_class}><code {lang_class}>"
+        else:
+            start_tag = "<pre><code>"
+        end_tag = "</code></pre>"
+
+        return start_tag + self.code + end_tag
+
+    def to_markdown(self) -> str:
+        """
+        :return: The markdown representation of this code block.
+        """
+        start_tag = f"```{self.language}\n"
+        end_tag = "```" if self.code.endswith("\n") else "\n```"
+
+        return start_tag + self.code + end_tag

sapiopycommons/general/sapio_links.py

@@ -10,7 +10,8 @@ class SapioNavigationLinker:
     Given a URL to a system's webservice API (example: https://company.exemplareln.com/webservice/api), construct
     URLs for navigation links to various locations in the system.
     """
-    base_url: str
+    client_url: str
+    webservice_url: str
 
     def __init__(self, url: str | SapioUser | SapioWebhookContext):
         """
@@ -21,7 +22,14 @@ class SapioNavigationLinker:
             url = url.user.url
         elif isinstance(url, SapioUser):
             url = url.url
-        self.base_url = url.rstrip("/").replace('webservice/api', 'veloxClient')
+        self.webservice_url = url.rstrip("/")
+        self.client_url = url.rstrip("/").replace('webservice/api', 'veloxClient')
+
+    def homepage(self) -> str:
+        """
+        :return: A URL for navigating to the system's homepage.
+        """
+        return self.client_url + "/#view=homepage"
 
     def data_record(self, record_identifier: RecordIdentifier, data_type_name: DataTypeIdentifier | None = None) -> str:
         """
@@ -39,7 +47,7 @@ class SapioNavigationLinker:
         if not data_type_name:
             raise SapioException("Unable to create a data record link without a data type name. "
                                  "Only a record ID was provided.")
-        return self.base_url + f"/#dataType={data_type_name};recordId={record_id};view=dataRecord"
+        return self.client_url + f"/#dataType={data_type_name};recordId={record_id};view=dataRecord"
 
     def experiment(self, experiment: ExperimentIdentifier) -> str:
         """
@@ -47,4 +55,4 @@ class SapioNavigationLinker:
             object, experiment protocol, or a notebook ID.
         :return: A URL for navigating to the input experiment.
         """
-        return self.base_url + f"/#notebookExperimentId={AliasUtil.to_notebook_id(experiment)};view=eln"
+        return self.client_url + f"/#notebookExperimentId={AliasUtil.to_notebook_id(experiment)};view=eln"

{sapiopycommons-2025.6.6a559.dist-info → sapiopycommons-2025.6.10a560.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.6.6a559
+Version: 2025.6.10a560
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>

{sapiopycommons-2025.6.6a559.dist-info → sapiopycommons-2025.6.10a560.dist-info}/RECORD

@@ -2,8 +2,8 @@ sapiopycommons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/callback_util.py,sha256=lnrwG9hCVmA2GuzxlRrGKw7Eq5hzz7GBZvizgcKkSX0,134996
 sapiopycommons/callbacks/field_builder.py,sha256=rnIP-RJafk3mZlAx1eJ8a0eSW9Ps_L6_WadCmusnENw,38772
-sapiopycommons/chem/IndigoMolecules.py,sha256=slM2y39zZFHc468c366EqR8T-GYJ24UnM9HWAqWFEwQ,3900
-sapiopycommons/chem/Molecules.py,sha256=5PzRyE1s-Z3nfwh3Y4dCNdQOIJGhog08wyZvgTkKwyU,12384
+sapiopycommons/chem/IndigoMolecules.py,sha256=7ucCaRMLu1zfH2uPIvXwRTSdpNcS03O1P9p_O-5B4xQ,5110
+sapiopycommons/chem/Molecules.py,sha256=mVqPn32MPMjF0iZas-5MFkS-upIdoW5OB72KKZmJRJA,12523
 sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/customreport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/customreport/auto_pagers.py,sha256=TeyvqesENFd66Ll1gwgP10RgJvgVT1dAOv1cKooCYDk,14860
@@ -40,8 +40,9 @@ sapiopycommons/general/custom_report_util.py,sha256=NwwmejSQLwSbrndEk1gPyFNYk9GZ
 sapiopycommons/general/data_structure_util.py,sha256=fbQR_Fh4Scg67IpFPbQW9wVLw1oxlYxqp4LjBRTpjgU,4702
 sapiopycommons/general/directive_util.py,sha256=7SeQrd2Ye5JHlXZtJZaVGgtaSLdq_Vm9EObuxf44Pz8,3905
 sapiopycommons/general/exceptions.py,sha256=aPlzK1cvxeMU5UsokYlLrIBGltUfJZ7LH8zvLh9DxpI,3233
+sapiopycommons/general/html_formatter.py,sha256=HE3OeGgwOw6x53zGSc4-UzP4-JoOmQIz3pX-DzNVg94,17138
 sapiopycommons/general/popup_util.py,sha256=HKILegU1uCL_6abNlNL0Wn3xgX2JNa_kJeq7e5CZu6Q,31923
-sapiopycommons/general/sapio_links.py,sha256=o9Z-8y2rz6AI0Cy6tq58ElPge9RBnisGc9NyccbaJxs,2610
+sapiopycommons/general/sapio_links.py,sha256=YkcVKNLrSGoM7tCCXBAsIbIxylctwdcEyhePrRMODe0,2859
 sapiopycommons/general/storage_util.py,sha256=ovmK_jN7v09BoX07XxwShpBUC5WYQOM7dbKV_VeLXJU,8892
 sapiopycommons/general/time_util.py,sha256=jU1urPoZRv6evNucR0-288EyT4PrsDpCr-H1-7BKq9A,12363
 sapiopycommons/multimodal/multimodal.py,sha256=PFaGJPbKvW__tnxb8KkgkJZOKjQdgxF_kGfD5chet1s,6779
@@ -61,7 +62,7 @@ sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 sapiopycommons/webhook/webhook_context.py,sha256=D793uLsb1691SalaPnBUk3rOSxn_hYLhdvkaIxjNXss,1909
 sapiopycommons/webhook/webhook_handlers.py,sha256=tUVNCw05CDGu1gFDm2g558hX_O203WVm_n__ojjoRRM,39841
 sapiopycommons/webhook/webservice_handlers.py,sha256=tyaYGG1-v_JJrJHZ6cy5mGCxX9z1foLw7pM4MDJlFxs,14297
-sapiopycommons-2025.6.6a559.dist-info/METADATA,sha256=4AOXsdz5fJeOr0fHu31TrnL4vifE8NkUXOjxlXs4rvw,3142
-sapiopycommons-2025.6.6a559.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-sapiopycommons-2025.6.6a559.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-sapiopycommons-2025.6.6a559.dist-info/RECORD,,
+sapiopycommons-2025.6.10a560.dist-info/METADATA,sha256=M4tA963cTPGJR8zHZNPz-HaeVhD_adMnBAVB1sli1gw,3143
+sapiopycommons-2025.6.10a560.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+sapiopycommons-2025.6.10a560.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2025.6.10a560.dist-info/RECORD,,