webcode-tk 1.2.11__tar.gz → 1.2.17__tar.gz

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/PKG-INFO

@@ -1,17 +1,16 @@
 Metadata-Version: 2.4
 Name: webcode-tk
-Version: 1.2.11
+Version: 1.2.17
 Summary: A set of tools for inspecting HTML and CSS code
 License: MIT
 License-File: LICENSE.rst
 Keywords: html,validation,css
 Author: hundredvisionsguy
 Author-email: cwinikka@gmail.com
-Requires-Python: >=3.9.0,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -22,7 +21,9 @@ Requires-Dist: file-clerk (>=1.0.9,<2.0.0)
 Requires-Dist: lxml (>=6.0.0,<7.0.0)
 Requires-Dist: mechanicalsoup (>=1.4.0,<2.0.0)
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
+Requires-Dist: pre-commit (>=4.5.0,<5.0.0)
 Requires-Dist: py-readability-metrics (>=1.4.5,<2.0.0)
+Requires-Dist: pytest (>=9.0.3,<10.0.0)
 Requires-Dist: pytest-mock (>=3.15.1,<4.0.0)
 Requires-Dist: requests (>=2.28.1,<3.0.0)
 Requires-Dist: textatistic (>=0.0.1,<0.0.2)

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "webcode-tk"
-version = "1.2.11"
+version = "1.2.17"
 description = "A set of tools for inspecting HTML and CSS code"
 authors = ["hundredvisionsguy <cwinikka@gmail.com>"]
 keywords = ["html", "validation", "css", ]
@@ -16,7 +16,7 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.9.0,<4.0"
+python = ">=3.10,<4.0"
 bs4 = "^0.0.1"
 file-clerk = "^1.0.9"
 requests = "^2.28.1"
@@ -27,6 +27,8 @@ tinycss2 = "^1.4.0"
 lxml = "^6.0.0"
 mechanicalsoup = "^1.4.0"
 pytest-mock = "^3.15.1"
+pre-commit = "^4.5.0"
+pytest = "^9.0.3"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "*"

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/__init__.py

@@ -40,4 +40,4 @@
 - **`validator_tools`**: sends HTML or CSS code to the W3C Validator to check
           for errors.
 """
-__version__ = "1.2.11"
+__version__ = "1.2.17"

webcode_tk-1.2.17/webcode_tk/_style_inheritance.py

@@ -0,0 +1,371 @@
+"""
+_style_inheritance.py
+By Chris Winikka
+
+Internal utiliities for computing CSS inheritance.
+
+This module provides optimized functions for computing CSS inheritance and
+visual background inheritance during contrast analysis. It is used internally
+by contrast_tools and is not part of the public API.
+
+Functions:
+    apply_css_inheritance: Apply inheritable CSS properties top-down through
+        DOM.
+    apply_visual_background_inheritance: Propagate background colors via
+        ancestry.
+    find_ancestor_background: Locate first ancestor with explicit background.
+    apply_inheritance: Wrapper combining CSS and visual inheritance.
+"""
+
+import re
+
+from bs4 import Tag
+
+DEFAULT_GLOBAL_BACKGROUND = "#ffffff"
+
+
+def apply_css_inheritance(computed_styles: dict) -> None:
+    """
+    Apply CSS inheritance top-down (parent to children) instead of bottom-up.
+
+    This is MUCH faster than walking up the tree for each element.
+    O(n) instead of O(n*m*h) where n=elements, m=properties, h=tree_depth
+    """
+    inheritable_props = {"color", "font-size", "font-weight"}
+
+    # Build parent-child relationships
+    parent_to_children = {}
+    child_to_parent = {}
+
+    for element in computed_styles:
+        parent = element.parent
+        if parent and parent in computed_styles:
+            if parent not in parent_to_children:
+                parent_to_children[parent] = []
+            parent_to_children[parent].append(element)
+            child_to_parent[element] = parent
+
+    # Process top-down: parent values flow to children
+    visited = set()
+
+    def traverse_tree(element, inherited_props_from_ancestors):
+        """DFS traversal pushing inherited values down."""
+        if element in visited:
+            return
+        visited.add(element)
+
+        if element not in computed_styles:
+            return
+
+        element_styles = computed_styles[element]
+        props_for_children = inherited_props_from_ancestors.copy()
+
+        # For each inheritable property
+        for prop in inheritable_props:
+            current_prop = element_styles.get(prop)
+
+            # If element has explicit rule, use it (don't inherit)
+            if current_prop and current_prop.get("source") == "rule":
+                props_for_children[prop] = current_prop
+            # Otherwise inherit from ancestor if available
+            elif prop in inherited_props_from_ancestors:
+                inherited_value = inherited_props_from_ancestors[prop]
+                element_styles[prop] = {
+                    "value": inherited_value["value"],
+                    "specificity": inherited_value["specificity"],
+                    "source": "inheritance",
+                    "selector": inherited_value.get("selector", "inherited"),
+                    "css_file": inherited_value.get("css_file"),
+                    "css_source_type": inherited_value.get("css_source_type"),
+                    "inherited_from": child_to_parent.get(element),
+                }
+                # Also pass inherited value to children
+                props_for_children[prop] = element_styles[prop]
+
+        # Recurse to children with updated inherited values
+        if element in parent_to_children:
+            for child in parent_to_children[element]:
+                traverse_tree(child, props_for_children)
+
+    # Start traversal from root elements (with no parent in computed_styles)
+    for element in computed_styles:
+        if element not in child_to_parent:
+            # This is a root element
+            traverse_tree(element, {})
+
+
+def apply_visual_background_inheritance(computed_styles: dict) -> None:
+    """
+    Apply visual background colors to elements without explicit backgrounds.
+
+    Args:
+        computed_styles: a dictionary of elements with computed styles.
+    Returns:
+        None
+    """
+
+    for element in computed_styles:
+        element_styles = computed_styles[element]
+
+        # Check for BOTH background-color AND background
+        current_bg = element_styles.get("background-color")
+        has_background_shorthand = "background" in element_styles
+
+        # If element has background shorthand, process it for images
+        if has_background_shorthand:
+            bg_value = element_styles["background"]["value"]
+
+            # Check if background contains a raster image
+            if contains_raster_image(bg_value):
+                # Mark as contrast-indeterminate - cannot analyze
+                element_styles["background-color"] = {
+                    "value": None,
+                    "specificity": "000",
+                    "contrast_analysis": "indeterminate",
+                    "reason": "background_image_blocks_color_analysis",
+                    "original_background": bg_value,
+                    "visual_inheritance": False,
+                }
+                continue
+            else:
+                # Has usable background shorthand - skip inheritance
+                continue
+        if not current_bg:
+            continue
+
+        bg_source = current_bg.get("source")
+        bg_value = current_bg.get("value")
+
+        # Skip elements with explicit CSS rules
+        if bg_source == "rule":
+            continue
+
+        # Only update elements that still have the default white background
+        # This prevents overwriting elements with existing proper backgrounds
+        if bg_source != "default":
+            continue
+
+        # Element needs background inheritance (lines 1120-1141)
+        ancestor_bg = find_ancestor_background(element, computed_styles)
+
+        if not ancestor_bg or ancestor_bg.get("source") == "default":
+            # No explicit background to inherit - keep browser default
+            continue
+
+        if ancestor_bg.get("contrast_analysis") == "indeterminate":
+            # Ancestor is indeterminate - propagate that status
+            element_styles["background-color"] = {
+                "value": None,
+                "specificity": "000",
+                "contrast_analysis": "indeterminate",
+                "reason": ancestor_bg["reason"],
+                "inherited_from": ancestor_bg["source_element"],
+                "source": "visual_inheritance",
+                "original_background": ancestor_bg.get("original_background"),
+            }
+
+        else:
+            # Normal inheritance - extract usable color
+            contrast_color = extract_contrast_color(ancestor_bg["value"])
+            effective_color = (
+                contrast_color if contrast_color else ancestor_bg["value"]
+            )
+            element_styles["background-color"] = {
+                "value": effective_color,
+                "specificity": "000",
+                "source": "visual_inheritance",
+                "inherited_from": ancestor_bg["source_element"],
+                "contrast_analysis": "determinable",
+                "original_background": (
+                    ancestor_bg["value"]
+                    if ancestor_bg["value"] != DEFAULT_GLOBAL_BACKGROUND
+                    else None
+                ),
+            }
+
+
+def contains_raster_image(background_value: str) -> bool:
+    """Check if background contains a raster image that blocks color analysis.
+
+    Args:
+        background_value: the css value applied to the background property.
+
+    Returns:
+        bool: whether the background value includes a raster image or not.
+    """
+    # Add None check
+    if background_value is None:
+        return False
+
+    return bool(
+        re.search(
+            r"url\([^)]*\.(jpg|jpeg|png|gif|webp|bmp)", background_value, re.I
+        )
+    )
+
+
+def extract_contrast_color(background_value: str) -> str:
+    """
+    Extract usable color for contrast analysis, or None.
+
+    Args:
+        background_value (str): CSS background property value.
+
+    Returns:
+        str: Color value suitable for contrast analysis, or None if no
+            usable color found.
+    """
+    # Add None check at the beginning
+    if background_value is None:
+        return None
+
+    # Remove raster images - they block color visibility
+    if re.search(
+        r"url\([^)]*\.(jpg|jpeg|png|gif|webp|bmp)", background_value, re.I
+    ):
+        return None
+
+    # Handle gradients - extract representative color
+    if "gradient" in background_value.lower():
+        return extract_gradient_contrast_color(background_value)
+
+    # Handle solid colors
+    re_pattern = r"(#[a-f0-9]{3,6}|rgb\([^)]+\)|rgba\([^)]+\)|hsl\([^)]+\)|"
+    re_pattern += r"hsla\([^)]+\)|[a-z]+)"
+    color_match = re.search(
+        re_pattern,
+        background_value,
+        re.I,
+    )
+    return color_match.group(1) if color_match else None
+
+
+def find_ancestor_background(element: Tag, computed_styles: dict) -> dict:
+    """
+    Walk up DOM tree to find first ancestor with background.
+
+    Args:
+        element (Tag): BeautifulSoup Tag object to start searching from.
+        computed_styles (dict): Dictionary mapping elements to their
+            computed styles.
+
+    Returns:
+        dict: Dictionary containing 'value' (background color) and
+            'source_element' (ancestor element or None).
+    """
+    current = element.parent
+
+    while current:
+        if current in computed_styles:
+            current_styles = computed_styles[current]
+
+            # Flag to track if we should skip this ancestor
+            skip_ancestor = False
+
+            # Check for background-color or background
+            for bg_prop in ["background-color", "background"]:
+                if bg_prop in current_styles:
+                    bg_source = current_styles[bg_prop].get("source")
+
+                    # Skip elements that only have visual inheritance
+                    if bg_source == "visual_inheritance":
+                        skip_ancestor = True
+                        break  # ✅ Break out of property loop
+
+                    # Accept both "rule" and "default" sources
+                    if bg_source in ["rule", "default"]:
+                        bg_value = current_styles[bg_prop]["value"]
+                        if bg_source == "default":
+                            # Skip ancestors with only default backgrounds
+                            skip_ancestor = True
+                            break
+
+                        # Does this ancestor already is indeterminate status
+                        if (
+                            current_styles[bg_prop].get("contrast_analysis")
+                            == "indeterminate"
+                        ):
+                            return {
+                                "value": None,
+                                "source_element": current,
+                                "contrast_analysis": "indeterminate",
+                                "reason": "ancestor_has_background_image",
+                                "original_background": current_styles[
+                                    bg_prop
+                                ].get("original_background", bg_value),
+                            }
+
+                        # Skip None values and continue searching
+                        if bg_value is None:
+                            continue  # Continue to next property
+
+                        # Check if this background contains a raster image
+                        if contains_raster_image(bg_value):
+                            return {
+                                "value": None,
+                                "source_element": current,
+                                "contrast_analysis": "indeterminate",
+                                "reason": "ancestor_has_background_image",
+                                "original_background": bg_value,
+                            }
+
+                        # Found explicit background
+                        bg_items = current_styles[bg_prop].items()
+                        return {
+                            "value": bg_value,
+                            "source_element": current,
+                            "contrast_analysis": "determinable",
+                            # Copy metadata from ancestor
+                            **{
+                                metadata_key: metadata_value
+                                for metadata_key, metadata_value in bg_items
+                                if metadata_key not in ["value"]
+                            },
+                        }
+
+            # If we flagged this ancestor to skip, move to next ancestor
+            if skip_ancestor:
+                current = current.parent
+                continue  # ✅ Now this continues to next ancestor
+
+        current = current.parent
+
+    # No ancestor background found, use default
+    return {
+        "value": DEFAULT_GLOBAL_BACKGROUND,
+        "source_element": None,
+        "contrast_analysis": "determinable",
+        "source": "default",
+    }
+
+
+def extract_gradient_contrast_color(background_value: str) -> str:
+    """
+    Extract representative color from gradient for contrast analysis.
+
+    Args:
+        background_value (str): CSS gradient value (e.g.,
+            'linear-gradient(red, blue)').
+
+    Returns:
+        str: Representative color for contrast analysis, or None if no
+            color found.
+    """
+    # Add None check
+    if background_value is None:
+        return None
+
+    # Strategy: Use the final color in gradient (most visible for reading)
+    # This handles: linear-gradient(red, blue) -> blue
+    #              radial-gradient(center, red, blue) -> blue
+
+    # Find all colors in gradient
+    color_pattern = r"(#[a-f0-9]{3,6}|rgb\([^)]+\)|rgba\([^)]+\)|"
+    color_pattern += r"hsl\([^)]+\)|hsla\([^)]+\)|[a-z]+)"
+    colors = re.findall(color_pattern, background_value, re.I)
+
+    if colors:
+        # Use last color (end of gradient)
+        return colors[-1]
+
+    return None

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/animation_tools.py

@@ -2,6 +2,7 @@
 A group of functions that work with css_tools and cascade_tools to provide
 reports on CSS animations.
 """
+
 from collections.abc import Iterable
 from typing import Union
 

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/cascade_tools.py

@@ -8,6 +8,7 @@ all styles applied to every element on the page.
 With that, it scans each stylesheet and applies each style one at a time
 to all elements and their children (if applicable) of a page.
 """
+
 import ctypes
 import re
 from collections import abc
@@ -1539,6 +1540,16 @@ def targets_element_directly(element: Element, selector: str) -> bool:
     elif selector_type == "id_selector":
         attributes = element.attributes
         if attributes:
+            if not isinstance(attributes, dict):
+                try:
+                    attributes = dict(attributes)
+                except Exception:
+                    msg = "This is not a dictionary and cannot be converted"
+                    msg += " into one!"
+                    raise ValueError(msg)
+            else:
+                data_type = str(type(attributes))
+                print(data_type)
             id_attribute = attributes.get("id")
             if id_attribute:
                 targets = selector in attributes.get("id")

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/color_keywords.py

@@ -231,7 +231,7 @@ def is_a_keyword(word: str) -> bool:
     return is_keyword
 
 
-def get_hex_by_keyword(word: (str)) -> str:
+def get_hex_by_keyword(word: str) -> str:
     """returns the hex value of a keyword (if valid).
 
     Args:

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/color_tools.py

@@ -19,6 +19,7 @@ One thing led to another, yada yada, then I realized that this could
 be a useful tool in my web grading projects, and there you have it:
 `color_tools`.
 """
+
 import re
 
 from webcode_tk import color_keywords
@@ -313,7 +314,7 @@ def has_alpha_channel(code: str) -> bool:
     """
     has_alpha = False
     if "#" in code:
-        if len(code) == 9:
+        if len(code) == 9 or len(code) == 5:
             has_alpha = True
     if "hsla(" in code:
         has_alpha = True
@@ -321,6 +322,10 @@ def has_alpha_channel(code: str) -> bool:
         has_alpha = True
     if "rgba(" in code:
         has_alpha = True
+    if "rgb" in code and "/" in code:
+        has_alpha = True
+    if "transparent" in code:
+        has_alpha = True
     return has_alpha
 
 

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/contrast_tools.py

@@ -31,6 +31,7 @@ Constants:
         mathematical contrast ratios and size thresholds that determine WCAG
         compliance.
 """
+
 import copy
 import re
 
@@ -40,6 +41,13 @@ from bs4 import NavigableString
 from bs4 import Tag
 from file_clerk import clerk
 
+from webcode_tk._style_inheritance import (
+    apply_css_inheritance,
+    apply_visual_background_inheritance,
+    contains_raster_image,
+    DEFAULT_GLOBAL_BACKGROUND,
+    extract_contrast_color,
+)
 from webcode_tk import color_tools
 from webcode_tk import css_tools
 from webcode_tk import font_tools
@@ -49,7 +57,6 @@ from webcode_tk.font_tools import split_value_unit
 
 # Browser default styling constants
 DEFAULT_GLOBAL_COLOR = "#000000"
-DEFAULT_GLOBAL_BACKGROUND = "#ffffff"
 DEFAULT_LINK_COLOR = "#0000EE"
 DEFAULT_LINK_VISITED = "#551A8B"
 ROOT_FONT_SIZE = 16
@@ -166,20 +173,6 @@ def generate_contrast_report(
     for file in project_files:
         errors = project_files.get(file)
 
-        # Check for global selectors (html, *, or body) and calculate contrast
-        global_color_result = css_tools.get_global_color_report(project_path)
-
-        if isinstance(global_color_result, list):
-            for result in global_color_result:
-                if file in result:
-                    # Always add global color failures
-                    if "fail" in result:
-                        error_msg = result.split(file)[1]
-                        msg = f"fail: in {file}, {error_msg.strip()}"
-                        # Add to errors list if not already there
-                        if msg not in project_files[file]:
-                            project_files[file].append(msg)
-
         # Now append to report
         if errors:
             if "has no CSS" in errors[0]:
@@ -885,12 +878,16 @@ def apply_rule_to_element(
                     "specificity": rule_specificity,
                     "source": "rule",
                     "selector": selector,
-                    "css_file": css_source_info.get("filename")
-                    if css_source_info
-                    else None,
-                    "css_source_type": css_source_info.get("source_type")
-                    if css_source_info
-                    else None,
+                    "css_file": (
+                        css_source_info.get("filename")
+                        if css_source_info
+                        else None
+                    ),
+                    "css_source_type": (
+                        css_source_info.get("source_type")
+                        if css_source_info
+                        else None
+                    ),
                 }
 
                 # Check if we should apply this font-size rule
@@ -925,12 +922,16 @@ def apply_rule_to_element(
                         "specificity": rule_specificity,
                         "source": "rule",
                         "selector": selector,
-                        "css_file": css_source_info.get("filename")
-                        if css_source_info
-                        else None,
-                        "css_source_type": css_source_info.get("source_type")
-                        if css_source_info
-                        else None,
+                        "css_file": (
+                            css_source_info.get("filename")
+                            if css_source_info
+                            else None
+                        ),
+                        "css_source_type": (
+                            css_source_info.get("source_type")
+                            if css_source_info
+                            else None
+                        ),
                         "contrast_analysis": "indeterminate",
                         "reason": "background_image_blocks_color_analysis",
                         "original_background": property_value,
@@ -947,16 +948,22 @@ def apply_rule_to_element(
                         "specificity": rule_specificity,
                         "source": "rule",
                         "selector": selector,
-                        "css_file": css_source_info.get("filename")
-                        if css_source_info
-                        else None,
-                        "css_source_type": css_source_info.get("source_type")
-                        if css_source_info
-                        else None,
+                        "css_file": (
+                            css_source_info.get("filename")
+                            if css_source_info
+                            else None
+                        ),
+                        "css_source_type": (
+                            css_source_info.get("source_type")
+                            if css_source_info
+                            else None
+                        ),
                         "contrast_analysis": "determinable",
-                        "original_background": property_value
-                        if property_value != effective_color
-                        else None,
+                        "original_background": (
+                            property_value
+                            if property_value != effective_color
+                            else None
+                        ),
                     }
 
                 # Apply specificity logic and set the property
@@ -1014,12 +1021,16 @@ def apply_rule_to_element(
                         "specificity": rule_specificity,
                         "source": "rule",
                         "selector": selector,
-                        "css_file": css_source_info.get("filename")
-                        if css_source_info
-                        else None,
-                        "css_source_type": css_source_info.get("source_type")
-                        if css_source_info
-                        else None,
+                        "css_file": (
+                            css_source_info.get("filename")
+                            if css_source_info
+                            else None
+                        ),
+                        "css_source_type": (
+                            css_source_info.get("source_type")
+                            if css_source_info
+                            else None
+                        ),
                     }
 
     return
@@ -1141,149 +1152,6 @@ def apply_inheritance(soup: BeautifulSoup, computed_styles: dict) -> None:
     apply_visual_background_inheritance(computed_styles)
 
 
-def apply_css_inheritance(computed_styles: dict) -> None:
-    """
-    Apply traditional CSS inheritance for inheritable properties.
-    Only inherit from the closest ancestor with an explicit rule.
-    """
-    inheritable_props = {"color", "font-size", "font-weight"}
-
-    for child_element in computed_styles:
-        child_styles = computed_styles[child_element]
-
-        # find closest ancestor with explicit value
-        for prop in inheritable_props:
-            child_prop = child_styles.get(prop)
-
-            # Skip if child has explicit CSS rule (not default)
-            if child_prop and child_prop.get("source") not in [
-                "default",
-                None,
-            ]:
-                continue
-
-            # Walk up tree to find first ancestor with explicit value
-            current = child_element.parent
-            inherited_value = None
-
-            while current and not inherited_value:
-                if current in computed_styles:
-                    parent_styles = computed_styles[current]
-                    parent_prop = parent_styles.get(prop)
-
-                    # Found a parent with this property
-                    if parent_prop:
-                        # Only inherit if parent has explicit rule
-                        if parent_prop.get("source") == "rule":
-                            inherited_value = parent_prop
-                            inherited_from = current
-                            break  # ← Stop at first explicit ancestor
-
-                current = current.parent
-
-            # Apply inherited value if found
-            if inherited_value:
-                child_styles[prop] = {
-                    "value": inherited_value["value"],
-                    "specificity": inherited_value["specificity"],
-                    "source": "inheritance",
-                    "selector": inherited_value.get("selector", "inherited"),
-                    "css_file": inherited_value.get("css_file"),
-                    "css_source_type": inherited_value.get("css_source_type"),
-                    "inherited_from": inherited_from,
-                }
-
-
-def apply_visual_background_inheritance(computed_styles: dict) -> None:
-    """
-    Apply visual background colors to elements without explicit backgrounds.
-
-    Args:
-        computed_styles: a dictionary of elements with computed styles.
-    Returns:
-        None
-    """
-
-    for element in computed_styles:
-        element_styles = computed_styles[element]
-
-        # Check for BOTH background-color AND background
-        current_bg = element_styles.get("background-color")
-        has_background_shorthand = "background" in element_styles
-
-        # If element has background shorthand, process it for images
-        if has_background_shorthand:
-            bg_value = element_styles["background"]["value"]
-
-            # Check if background contains a raster image
-            if contains_raster_image(bg_value):
-                # Mark as contrast-indeterminate - cannot analyze
-                element_styles["background-color"] = {
-                    "value": None,
-                    "specificity": "000",
-                    "contrast_analysis": "indeterminate",
-                    "reason": "background_image_blocks_color_analysis",
-                    "original_background": bg_value,
-                    "visual_inheritance": False,
-                }
-                continue
-            else:
-                # Has usable background shorthand - skip inheritance
-                continue
-        if not current_bg:
-            continue
-
-        bg_source = current_bg.get("source")
-        bg_value = current_bg.get("value")
-
-        # Skip elements with explicit CSS rules
-        if bg_source == "rule":
-            continue
-
-        # Only update elements that still have the default white background
-        # This prevents overwriting elements with existing proper backgrounds
-        if bg_source != "default":
-            continue
-
-        # Element needs background inheritance (lines 1120-1141)
-        ancestor_bg = find_ancestor_background(element, computed_styles)
-
-        if not ancestor_bg or ancestor_bg.get("source") == "default":
-            # No explicit background to inherit - keep browser default
-            continue
-
-        if ancestor_bg.get("contrast_analysis") == "indeterminate":
-            # Ancestor is indeterminate - propagate that status
-            element_styles["background-color"] = {
-                "value": None,
-                "specificity": "000",
-                "contrast_analysis": "indeterminate",
-                "reason": ancestor_bg["reason"],
-                "inherited_from": ancestor_bg["source_element"],
-                "source": "visual_inheritance",
-                "original_background": ancestor_bg.get("original_background"),
-            }
-
-        else:
-            # Normal inheritance - extract usable color
-            contrast_color = extract_contrast_color(ancestor_bg["value"])
-            effective_color = (
-                contrast_color if contrast_color else ancestor_bg["value"]
-            )
-            element_styles["background-color"] = {
-                "value": effective_color,
-                "specificity": "000",
-                "source": "visual_inheritance",
-                "inherited_from": ancestor_bg["source_element"],
-                "contrast_analysis": "determinable",
-                "original_background": (
-                    ancestor_bg["value"]
-                    if ancestor_bg["value"] != DEFAULT_GLOBAL_BACKGROUND
-                    else None
-                ),
-            }
-
-
 def has_usable_background_color(background_prop: dict) -> bool:
     """
     Check if background property contains usable color for contrast.
@@ -1313,193 +1181,6 @@ def has_usable_background_color(background_prop: dict) -> bool:
     )
 
 
-def contains_raster_image(background_value: str) -> bool:
-    """Check if background contains a raster image that blocks color analysis.
-
-    Args:
-        background_value: the css value applied to the background property.
-
-    Returns:
-        bool: whether the background value includes a raster image or not.
-    """
-    # Add None check
-    if background_value is None:
-        return False
-
-    return bool(
-        re.search(
-            r"url\([^)]*\.(jpg|jpeg|png|gif|webp|bmp)", background_value, re.I
-        )
-    )
-
-
-def extract_contrast_color(background_value: str) -> str:
-    """
-    Extract usable color for contrast analysis, or None.
-
-    Args:
-        background_value (str): CSS background property value.
-
-    Returns:
-        str: Color value suitable for contrast analysis, or None if no
-            usable color found.
-    """
-    # Add None check at the beginning
-    if background_value is None:
-        return None
-
-    # Remove raster images - they block color visibility
-    if re.search(
-        r"url\([^)]*\.(jpg|jpeg|png|gif|webp|bmp)", background_value, re.I
-    ):
-        return None
-
-    # Handle gradients - extract representative color
-    if "gradient" in background_value.lower():
-        return extract_gradient_contrast_color(background_value)
-
-    # Handle solid colors
-    re_pattern = r"(#[a-f0-9]{3,6}|rgb\([^)]+\)|rgba\([^)]+\)|hsl\([^)]+\)|"
-    re_pattern += r"hsla\([^)]+\)|[a-z]+)"
-    color_match = re.search(
-        re_pattern,
-        background_value,
-        re.I,
-    )
-    return color_match.group(1) if color_match else None
-
-
-def extract_gradient_contrast_color(background_value: str) -> str:
-    """
-    Extract representative color from gradient for contrast analysis.
-
-    Args:
-        background_value (str): CSS gradient value (e.g.,
-            'linear-gradient(red, blue)').
-
-    Returns:
-        str: Representative color for contrast analysis, or None if no
-            color found.
-    """
-    # Add None check
-    if background_value is None:
-        return None
-
-    # Strategy: Use the final color in gradient (most visible for reading)
-    # This handles: linear-gradient(red, blue) -> blue
-    #              radial-gradient(center, red, blue) -> blue
-
-    # Find all colors in gradient
-    color_pattern = r"(#[a-f0-9]{3,6}|rgb\([^)]+\)|rgba\([^)]+\)|"
-    color_pattern += r"hsl\([^)]+\)|hsla\([^)]+\)|[a-z]+)"
-    colors = re.findall(color_pattern, background_value, re.I)
-
-    if colors:
-        # Use last color (end of gradient)
-        return colors[-1]
-
-    return None
-
-
-def find_ancestor_background(element: Tag, computed_styles: dict) -> dict:
-    """
-    Walk up DOM tree to find first ancestor with background.
-
-    Args:
-        element (Tag): BeautifulSoup Tag object to start searching from.
-        computed_styles (dict): Dictionary mapping elements to their
-            computed styles.
-
-    Returns:
-        dict: Dictionary containing 'value' (background color) and
-            'source_element' (ancestor element or None).
-    """
-    current = element.parent
-
-    while current:
-        if current in computed_styles:
-            current_styles = computed_styles[current]
-
-            # Flag to track if we should skip this ancestor
-            skip_ancestor = False
-
-            # Check for background-color or background
-            for bg_prop in ["background-color", "background"]:
-                if bg_prop in current_styles:
-                    bg_source = current_styles[bg_prop].get("source")
-
-                    # Skip elements that only have visual inheritance
-                    if bg_source == "visual_inheritance":
-                        skip_ancestor = True
-                        break  # ✅ Break out of property loop
-
-                    # Accept both "rule" and "default" sources
-                    if bg_source in ["rule", "default"]:
-                        bg_value = current_styles[bg_prop]["value"]
-                        if bg_source == "default":
-                            # Skip ancestors with only default backgrounds
-                            skip_ancestor = True
-                            break
-
-                        # Does this ancestor already is indeterminate status
-                        if (
-                            current_styles[bg_prop].get("contrast_analysis")
-                            == "indeterminate"
-                        ):
-                            return {
-                                "value": None,
-                                "source_element": current,
-                                "contrast_analysis": "indeterminate",
-                                "reason": "ancestor_has_background_image",
-                                "original_background": current_styles[
-                                    bg_prop
-                                ].get("original_background", bg_value),
-                            }
-
-                        # Skip None values and continue searching
-                        if bg_value is None:
-                            continue  # Continue to next property
-
-                        # Check if this background contains a raster image
-                        if contains_raster_image(bg_value):
-                            return {
-                                "value": None,
-                                "source_element": current,
-                                "contrast_analysis": "indeterminate",
-                                "reason": "ancestor_has_background_image",
-                                "original_background": bg_value,
-                            }
-
-                        # Found explicit background
-                        bg_items = current_styles[bg_prop].items()
-                        return {
-                            "value": bg_value,
-                            "source_element": current,
-                            "contrast_analysis": "determinable",
-                            # Copy metadata from ancestor
-                            **{
-                                metadata_key: metadata_value
-                                for metadata_key, metadata_value in bg_items
-                                if metadata_key not in ["value"]
-                            },
-                        }
-
-            # If we flagged this ancestor to skip, move to next ancestor
-            if skip_ancestor:
-                current = current.parent
-                continue  # ✅ Now this continues to next ancestor
-
-        current = current.parent
-
-    # No ancestor background found, use default
-    return {
-        "value": DEFAULT_GLOBAL_BACKGROUND,
-        "source_element": None,
-        "contrast_analysis": "determinable",
-        "source": "default",
-    }
-
-
 def is_inheritable_property(property_name: str) -> bool:
     """
     Determines if a CSS property is inheritable by default.
@@ -1557,25 +1238,6 @@ def analyze_elements_for_contrast(
             "contrast_analysis"
         )
 
-        # Check if this element inherited both text and background colors
-        text_color_source_type = extract_property_source(
-            element_data["color"]
-        ).get("source_type")
-        bg_color_source_type = extract_property_source(
-            element_data["background-color"]
-        ).get("source_type")
-
-        # Determine if this is a global color failure
-        inherited_text = text_color_source_type in [
-            "inherited",
-            "browser_default",
-        ]
-        inherited_bg = bg_color_source_type in [
-            "visual_inheritance",
-            "browser_default",
-        ]
-        is_global_failure = inherited_text and inherited_bg
-
         if is_large:
             aaa_results = contrast_report.get("Large AAA")
             aa_results = contrast_report.get("Large AA")
@@ -1607,7 +1269,6 @@ def analyze_elements_for_contrast(
             "wcag_aa_pass": aa_results,
             "wcag_aaa_pass": aaa_results,
             "contrast_analysis": contrast_analysis,
-            "global_color_failure": is_global_failure,
         }
 
         # add to results
@@ -1684,9 +1345,11 @@ def extract_property_source(property_data: dict) -> dict:
             "source_type": "visual_inheritance",
             "css_file": "visual_cascade",
             "selector": "ancestor_background",
-            "inherited_from": getattr(inherited_element, "name", None)
-            if inherited_element
-            else None,
+            "inherited_from": (
+                getattr(inherited_element, "name", None)
+                if inherited_element
+                else None
+            ),
         }
     elif source_type == "rule":
         return {

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/css_tools.py

@@ -2,6 +2,7 @@
 This module is a set of tools to analyze CSS syntax as well as properties
 and values.
 """
+
 import re
 from typing import Union
 
@@ -1234,7 +1235,7 @@ def get_colors_from_gradient(gradient: str) -> list:
     return colors
 
 
-def get_comment_positions(code: (str)) -> Union[list, None]:
+def get_comment_positions(code: str) -> Union[list, None]:
     """looks for index positions of first opening and closing comment.
 
     From this function, you can create a slice of a comment from the
@@ -1383,7 +1384,11 @@ def get_global_color_details(rulesets: Union[list, tuple]) -> list:
     global_selectors = ("html", "body", ":root", "*")
     global_rulesets = []
     for ruleset in rulesets:
-        if ruleset.selector in global_selectors:
+        if (
+            ruleset.selector in global_selectors
+            or "html" in ruleset.selector[:4]
+            or "body" in ruleset.selector[:4]
+        ):
             selector = ruleset.selector
             background_color = ""
             color = ""
@@ -1392,10 +1397,6 @@ def get_global_color_details(rulesets: Union[list, tuple]) -> list:
                     background_color = declaration.value
                 elif declaration.property == "color":
                     color = declaration.value
-                    if is_gradient(color):
-                        colors = process_gradient(color)
-                        todo = input("We have colors: " + colors)
-                        print(todo)
                 elif declaration.property == "background":
                     background_color = declaration.value
                     if is_gradient(background_color):
@@ -2452,22 +2453,93 @@ def get_global_color_report(project_dir: str, level="aaa") -> list:
     for data in all_file_data:
         filename = data[0]
         passes = []
+        global_data = {
+            "selector": "",
+            "specificity": "",
+            "bg_color": "",
+            "color": "",
+            "contrast_ratio": 0.0,
+            "passes_normal": False,
+            "passes_large": False,
+        }
         for sheet in data[1]:
             rules = sheet.rulesets
             global_color_data = get_global_color_details(rules)
             if global_color_data:
-                for item in global_color_data:
-                    file, result = get_color_data(filename, item, level)
-                    if "fail" in result:
-                        passes.append(f"fail: {file} {result}")
+                previous_selector = global_data.get("selector")
+                if previous_selector:
+                    previous_data = global_data.copy()
+
+                data = global_color_data[0]
+                current_selector = data.get("selector")
+                global_data["selector"] = current_selector
+
+                current_specificity = get_specificity(current_selector)
+                global_data["specificity"] = current_specificity
+
+                bg_color = data.get("background-color")
+                global_data["bg_color"] = bg_color
+
+                color = data.get("color")
+                global_data["color"] = color
+
+                ratio = data.get("contrast_ratio")
+                global_data["contrast_ratio"] = ratio
+
+                if level == "aaa":
+                    passes_normal = data.get("passes_normal_aaa")
+                    passes_large = data.get("passes_large_aaa")
+                else:
+                    passes_normal = data.get("passes_normal_aa")
+                    passes_large = data.get("passes_large_aa")
+
+                global_data["passes_normal"] = passes_normal
+                global_data["passes_large"] = passes_large
+
+                # If there was a previous selector
+                if previous_selector:
+                    previous_specificity = previous_data.get("specificity")
+
+                    # If previous specificity is higher, we need everything
+                    # from previous
+                    if previous_specificity > current_specificity:
+                        # Keep all from previous data
+                        for key, val in previous_data.items():
+                            if key in ["bg_color", "color"] and val:
+                                global_data[key] = val
                     else:
-                        passes.append(f"pass: {file} {result}")
-        if passes:
-            details = ""
-            for detail in passes:
-                details += detail
+                        # we already overrode everything
+                        # Anything missing? We need to pull from previous data
+                        for key, val in global_data.items():
+                            if not val:
+                                new_val = previous_data.get(key)
+                                if new_val:
+                                    global_data[key] = new_val
+        # reassess color contrast for global_data
+        bg_color = global_data.get("bg_color")
+        color = global_data.get("color")
+        if not bg_color or not color:
+            details = f"fail: {filename} does not apply "
+            if not bg_color and not color:
+                details += "neither background nor text color."
+            elif not bg_color:
+                details += "background color."
+            else:
+                details += "text color."
         else:
-            details = f"fail: {filename} does NOT apply global colors"
+            bg_hex = color_tools.get_hex(bg_color)
+            color_hex = color_tools.get_hex(color)
+            contrast_ratio = color_tools.contrast_ratio(bg_hex, color_hex)
+            normal_level = f"Normal {level.upper()}"
+            passes = color_tools.passes_color_contrast(
+                normal_level, bg_hex, color_hex
+            )
+            if passes:
+                details = f"pass: {filename} applies global colors and passes"
+                details += f" Normal {level.upper()} at a ratio of "
+                details += f"{contrast_ratio}:1."
+            else:
+                details = f"fail: {filename} does NOT apply global colors"
         report.append(details)
     if not report:
         report.append("fail: no html files to apply color styles to")

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/font_tools.py

@@ -21,6 +21,7 @@ I will also not support calculating `ch` or `ex` since those are
 dependent upon the font-family itself and require information from the
 font-file or some other hidden calculation from the browser.
 """
+
 import re
 from typing import Any
 from typing import Union

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/html_tools.py

@@ -12,6 +12,7 @@ elements were present or not.
     Typical usage example:
     ``
 """
+
 import os
 import re
 from typing import Union

{webcode_tk-1.2.11 → webcode_tk-1.2.17}/webcode_tk/ux_tools.py

@@ -15,6 +15,7 @@ According to the article...
     blocks of text
     - Use hypertext to split up long information into multiple pages"
 """
+
 import re
 from collections.abc import Sequence
 from typing import Union