webcode-tk 1.1.3__tar.gz → 1.1.5__tar.gz

{webcode_tk-1.1.3 → webcode_tk-1.1.5}/PKG-INFO

@@ -1,17 +1,16 @@
 Metadata-Version: 2.1
 Name: webcode-tk
-Version: 1.1.3
+Version: 1.1.5
 Summary: 
 Home-page: https://github.com/HundredVisionsGuy/webcode-tk
 License: MIT
 Keywords: html,validation,css
 Author: hundredvisionsguy
 Author-email: cwinikka@gmail.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.9.0,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{webcode_tk-1.1.3 → webcode_tk-1.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "webcode-tk"
-version = "1.1.3"
+version = "1.1.5"
 description = ""
 authors = ["hundredvisionsguy <cwinikka@gmail.com>"]
 keywords = ["html", "validation", "css", ]
@@ -16,7 +16,7 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = ">=3.9.0,<4.0"
 bs4 = "^0.0.1"
 file-clerk = "^1.0.9"
 lxml = "^4.9.1"

{webcode_tk-1.1.3 → webcode_tk-1.1.5}/webcode_tk/__init__.py

@@ -9,6 +9,7 @@ Modules exported by this package:
           properties and hex and rgb values.
 - `color_tools`: processes CSS color related properties and values.
 - `css_tools`: creates Stylesheet objects that store CSS information.
+- `font_tools`: A collection of functions used to process font-related styles.
 - `html_tools`: gets html files from a project folder, gets the HTML code
           from files, gets number of a particular element in a file
           or folder, gets elements as tags, and much more.
@@ -18,4 +19,4 @@ Modules exported by this package:
 - `validator_tools`: sends HTML or CSS code to the W3C Validator to check
           for errors.
 """
-__version__ = "1.1.3"
+__version__ = "1.1.5"

{webcode_tk-1.1.3 → webcode_tk-1.1.5}/webcode_tk/cascade_tools.py

@@ -13,6 +13,7 @@ import re
 from collections import abc
 from typing import Union
 
+from bs4 import NavigableString
 from file_clerk import clerk
 
 from webcode_tk import color_tools as color
@@ -69,6 +70,7 @@ class Element(object):
         parent=None,
         parent_size=root_font_size,
         ancestors=None,
+        tag_contents=None,
     ) -> None:
         self.name = name
         self.attributes = attributes
@@ -104,6 +106,10 @@ class Element(object):
                 value, unit, parent_size, name
             )
             self.is_bold = True
+        self.direct_text = ""
+        if tag_contents:
+            self.__set_direct_text(tag_contents)
+        self.has_direct_text = bool(self.direct_text)
         self.visited_color = {
             "value": "",
             "sheet": "",
@@ -164,6 +170,16 @@ class Element(object):
         if parent:
             self.ancestors.append(self.parent)
 
+    def __set_direct_text(self, contents: list):
+        """get only text not in a tag"""
+        text = ""
+        for i in contents:
+            if isinstance(i, NavigableString):
+                new_text = str(i)
+                if new_text != "\n":
+                    text += new_text.strip()
+        self.direct_text = text
+
     def __set_link_color(self):
         if self.name == "a":
             self.color["value"] = default_link_color
@@ -239,12 +255,6 @@ class Element(object):
                     self.visited_background["value"] = new_bg
                     self.visited_background["specificity"] = new_specificity
 
-            # Do we have a link selector?
-            is_link_selector = css.is_link_selector(selector)
-            if is_link_selector:
-                print("We have a link selector in ammend_color_styles")
-                print("I suppose we should check specificity")
-
     def ammend_bg_color(
         self,
         bg_color: str,
@@ -335,11 +345,6 @@ class Element(object):
             hexc: the hex code for the color value.
             hexbg: the hex code for the background color.
         """
-        bg_gradient = color.is_gradient(hexbg)
-        c_gradient = color.is_gradient(hexc)
-        if bg_gradient or c_gradient:
-            # worst contrast ratio takes the hit
-            print("let's process this")
         link_contrast = color.get_color_contrast_report(hexc, hexbg)
         link_ratio = color.contrast_ratio(hexc, hexbg)
 
@@ -364,9 +369,6 @@ class Element(object):
             hexc: the hex code for the color value.
             hexbg: the hex code for the background color.
         """
-        has_gradient = color.is_gradient(hexc) or color.is_gradient(hexbg)
-        if has_gradient:
-            print()
         link_contrast = color.get_color_contrast_report(hexc, hexbg)
         link_ratio = color.contrast_ratio(hexc, hexbg)
 
@@ -565,8 +567,13 @@ class Element(object):
                                 targets = True
                                 break
                 if selector_type == "id_selector":
+                    # NOTE: testing has not uncovered this state
+                    # we're keeping it here just in case
                     if "id" in self.attributes.keys():
-                        print("do like we do for classes")
+                        for val in self.attributes.get("id"):
+                            if val == selector[1:]:
+                                targets = True
+                                break
         return targets
 
     def been_applied(self, property: str) -> bool:
@@ -673,6 +680,7 @@ class Element(object):
                 self.background_color["value"] = val
                 self.background_color["sheet"] = filename
                 self.background_color["applied_by"] = "context"
+                self.background_color["selector"] = selector
 
 
 class CSSAppliedTree:
@@ -758,7 +766,7 @@ class CSSAppliedTree:
         parent_bg = root.background_color.get("value")
         body = Element(
             "body",
-            parent=("html", root_id, parent_bg),
+            parent=["html", root_id, parent_bg],
             parent_size=root_font_size,
         )
         body.parent_size = body.font_size
@@ -792,40 +800,58 @@ class CSSAppliedTree:
                 continue
             tag_children = tag.contents
             tag_attributes = tag.attrs
-            parent = (element.name, id(element))
+            parent = [element.name, id(element)]
             new_element = Element(
                 tag_name,
                 attributes=tag_attributes,
                 parent=parent,
                 parent_size=element.font_size,
                 ancestors=element.ancestors,
+                tag_contents=tag.contents,
             )
             self.__adjust_font_size(new_element)
             element.children.append(new_element)
-            for tag in tag_children:
-                if tag and not isinstance(tag, str):
-                    their_kids = tag.contents
-                    kids_attributes = tag.attrs
+            for item in tag_children:
+                if item and not isinstance(item, str):
+                    their_kids = item.contents
+                    kids_attributes = item.attrs
                     if kids_attributes:
                         kid_element = Element(
-                            tag.name,
+                            item.name,
                             attributes=kids_attributes,
-                            parent=(new_element.name, id(new_element)),
+                            parent=[new_element.name, id(new_element)],
                             parent_size=new_element.font_size,
                             ancestors=new_element.ancestors,
+                            tag_contents=item.contents,
                         )
                     else:
                         kid_element = Element(
-                            tag.name,
-                            parent=(new_element.name, id(new_element)),
+                            item.name,
+                            parent=[new_element.name, id(new_element)],
                             parent_size=new_element.font_size,
                             ancestors=new_element.ancestors,
+                            tag_contents=item.contents,
                         )
                     self.__adjust_font_size(kid_element)
                     new_element.children.append(kid_element)
                     self.__get_children(kid_element, their_kids)
         return
 
+    def extract_selectors(self, element):
+        """Get background color and color selectors"""
+        bg_data = ""
+        col_data = ""
+        if isinstance(element, Element):
+            if element.background_color.get("selector"):
+                bg_color = element.background_color.get("value")
+                bg_selector = element.background_color.get("selector")
+                bg_data = f"bg: {bg_color} selector: {bg_selector}"
+            if element.color.get("selector"):
+                color = element.color.get("value")
+                col_selector = element.color.get("selector")
+                col_data = f"color: {color} selector: {col_selector}"
+        return bg_data, col_data
+
     def __adjust_largeness(self) -> None:
         """sets the is_large property based on whether it's bold or not
         and the computed font size.
@@ -936,6 +962,7 @@ class CSSAppliedTree:
         filename: str,
         applied_by="default",
         selector_src="",
+        parent=None,
     ) -> None:
         """recursively adjust color where necessary to all elements that
         apply.
@@ -952,6 +979,22 @@ class CSSAppliedTree:
             element: the element in question.
             ruleset: the ruleset we want to apply.
             filename: the file where the styles came from."""
+        # If there is a parent, it's a good time to adjust the direct ancestor
+        if parent:
+            bg_sel, col_sel = self.extract_selectors(parent)
+            direct_ancestor = element.ancestors[-1]
+            if len(direct_ancestor) == 2:
+                direct_ancestor.append("")
+            if len(direct_ancestor) == 3:
+                direct_ancestor.append(bg_sel)
+                direct_ancestor.append(col_sel)
+            elif len(direct_ancestor) == 4:
+                direct_ancestor[-1] = bg_sel
+                direct_ancestor.append(col_sel)
+            elif len(direct_ancestor) == 5:
+                direct_ancestor[-2] = bg_sel
+                direct_ancestor[-1] = col_sel
+
         # Adjust colors if necessary - if there was a change,
         # adjust colors for children
         selector = list(ruleset.keys())[0]
@@ -1000,32 +1043,6 @@ class CSSAppliedTree:
                 self.__adjust_child_colors(
                     child, ruleset, filename, element_name
                 )
-        elif is_background_prop:
-            # background - if not set directly - apply by context
-            value = declaration.get("background-color")
-            if not value:
-                value = declaration.get("background")
-            if property == "background-image":
-                value = declaration.get("background-image")
-
-            # adjust if value is not the same as current value
-            applied_by = element.background_color.get("applied_by")
-            current_value = element.background_color.get("value")
-            time_to_adjust = (
-                applied_by == "default"
-                or applied_by == "context"
-                and value != current_value
-            )
-            # But only if the value was applied to an ancestor
-            # For example, a th is not a parent of a td
-            applied_to_ancestor = False
-            for ancestor in element.ancestors:
-                ancestor_tag = ancestor[0]
-                if ancestor_tag == selector_src:
-                    applied_to_ancestor = True
-            time_to_adjust = time_to_adjust and applied_to_ancestor
-            if time_to_adjust:
-                print("Wait")
         can_inherit = self.can_inherit_styles(element, selector, ruleset)
         if can_inherit and applies:
             declaration = ruleset.get(selector)
@@ -1034,7 +1051,7 @@ class CSSAppliedTree:
                 selector, declaration.copy(), new_specificity, filename
             )
         for child in element.children:
-            self.__adjust_colors(child, ruleset, filename)
+            self.__adjust_colors(child, ruleset, filename, parent=element)
 
     def __adjust_child_colors(
         self,
@@ -1060,6 +1077,8 @@ class CSSAppliedTree:
             filename: name of the file where the styles came from
             applied_from: the name of the element that was targetted
         """
+        # First adjust direct ancestor
+
         # Adjust colors if necessary - if there was a change,
         # adjust colors for children
         selector = list(ruleset.keys())[0]
@@ -1607,9 +1626,10 @@ def update_contrast_results(
 def get_color_contrast_details(tree: CSSAppliedTree, rating="AAA") -> list:
     """returns a list of all failures or a pass based on rating
 
-    We'll create a recursive inner nested function to traverse the DOM. We will
-    target only the styles that are applied directly so as to not overwhelm the
-    user and allow fixing the error more easily.
+    We'll create a recursive inner nested function to traverse the DOM. We
+    will target all elements, and then report on number of errors triggered
+    by each selector to help avoid overwhelming the user with too many
+    errors.
 
     Args:
         tree: the cascade tree for a single file.
@@ -1624,68 +1644,183 @@ def get_color_contrast_details(tree: CSSAppliedTree, rating="AAA") -> list:
     elements = tree.children
 
     def check_element(
-        el: Element, rating: str, filename: str
+        el: Element, rating: str, filename: str, parent_sel=None
     ) -> Union[list, None]:
         children = el.children
-        msg = ""
-        applied_directly = (
-            el.background_color.get("applied_by") == "directly"
-            or el.color.get("applied_by") == "directly"
-        )
-        if applied_directly or el.name == "body":
-            is_gradient = el.background_color.get("is_gradient")
-            if is_gradient:
-                # get worst case
-                worst_case = el.background_color.get("worst_contrast")
-                worst_results = worst_case.get("results")
-                fails = "fail" in worst_results[:5]
-                if fails:
-                    selector = el.background_color.get("selector")
-                    if el.is_large:
-                        size = "Large"
-                    else:
-                        size = "Normal"
-                    msg = f"{el.name} tag (selector: {selector}) fails color "
-                    msg += f"contrast at {size} {rating}."
-                    results.append(msg)
-                    return
-            contrast_data = el.contrast_data
-            if el.is_large:
-                if rating == "AAA":
-                    passes = contrast_data.get("large_aaa")
-                else:
-                    passes = contrast_data.get("large_aa")
-            else:
-                if rating == "AAA":
-                    passes = contrast_data.get("normal_aaa")
-                else:
-                    passes = contrast_data.get("normal_aa")
 
-            # only add results if failure
-            if not passes:
+        is_gradient = el.background_color.get("is_gradient")
+
+        # if the gradient was not directly applied, we won't get is_gradient
+        # since it might be applied contextually, we should double check
+        if not is_gradient:
+            bg_value = el.background_color.get("value")
+            is_gradient = "gradient" in bg_value
+
+            # we should recalculate contrast if it didn't register
+            if is_gradient:
+                fg_color = el.color.get("value")
+                bg_color = el.background_color.get("value")
+                contrast_details = color.get_color_contrast_with_gradients(
+                    fg_color, bg_color, el.ancestors
+                )
+                worst_case = {
+                    "has_alpha": False,
+                    "computed_value": "",
+                    "contrast_ratio": 0.0,
+                    "results": "",
+                }
+                contrast, fg_color = contrast_details[0][:2]
+                composite_bg, bg_has_alpha = contrast_details[0][3:]
+                worst_case["has_alpha"] = bg_has_alpha
+                worst_case["computed_value"] = composite_bg
+                worst_case["contrast_ratio"] = contrast
+                hex1 = color.get_hex(fg_color)
+                hex2 = color.get_hex(composite_bg)
+                passes_contrast = color.get_contrast_results_from_ratio(
+                    contrast, el.font_size, el.is_bold
+                )
+                worst_case["results"] = passes_contrast
+                el.background_color["worst_contrast"] = worst_case
+        if is_gradient:
+            # get worst case
+            worst_case = el.background_color.get("worst_contrast")
+            worst_results = worst_case.get("results")
+            fails = "fail" in worst_results[:5]
+            if "conditional pass" in worst_results:
+                if rating not in worst_results:
+                    fails = True
+            if fails:
+                selector = el.background_color.get("selector")
                 if el.is_large:
                     size = "Large"
                 else:
                     size = "Normal"
-                selector = el.background_color.get("selector")
-                if not selector:
-                    selector = el.color.get("selector")
-                msg = f"selector: {selector} fails color contrast {size}"
-                msg += f"{rating}"
-                results.append(msg)
+                if el.has_direct_text:
+                    if not selector and parent_sel:
+                        selector = parent_sel
+                        results.append((filename, selector, size, rating))
+
+                    # NOTE: it's possible we won't be able to get a selector
+                    # in the future. If so, add an else block and deal with it
+
+                else:
+                    # We have a failure, but without direct text
+                    # We need to verify whether the failure is passed
+                    # on to the children or not
+                    parent_bg = el.background_color
+                    parent_bg_selector = parent_bg.get("selector")
+                    parent_col = el.color
+                    parent_col_selector = parent_col.get("selector")
+                    for child in children:
+                        child_bg_val = child.background_color.get("value")
+                        child_col_val = child.color.get("value")
+
+                        # Check to see if the values in the child are the
+                        # same as with the parent, in which case, if parent
+                        # fails, then child should too
+                        if child_bg_val == parent_bg.get(
+                            "value"
+                        ) and child_col_val == parent_col.get("value"):
+                            selector = parent_bg_selector
+                            if not selector:
+                                selector = parent_col_selector
+
+                            # double check to make sure child is same size or
+                            # smaller than parent (size is parent's size)
+                            if size == "Normal" and child.is_large:
+                                hex1 = color.get_hex(child_bg_val)
+
+                                # In case the bg color is a gradient, we
+                                # need to pull from parent's bg_data
+                                if not hex1:
+                                    css_color = parent_bg.get("computed_value")
+                                    if css_color:
+                                        hex1 = color.get_hex(css_color)
+                                    else:
+                                        parent_bg_val = worst_case.get("value")
+                                        hex1 = color.get_hex(parent_bg_val)
+                                hex2 = color.get_hex(child_col_val)
+                                child_contrast = (
+                                    color.get_color_contrast_report(hex1, hex2)
+                                )
+                                child_sizing = f"Large {rating}"
+                                passes = "Fail" != child_contrast.get(
+                                    child_sizing
+                                )
+                                if not passes:
+                                    results.append(
+                                        (filename, selector, size, rating)
+                                    )
+                            else:
+                                results.append(
+                                    (filename, selector, size, rating)
+                                )
+
+                        # TODO: add tests to look for a parent with normal
+                        # size and a child that's large - make an else block
+                return
+        contrast_data = el.contrast_data
+        if el.is_large:
+            if rating == "AAA":
+                passes = contrast_data.get("large_aaa")
+            else:
+                passes = contrast_data.get("large_aa")
+        else:
+            if rating == "AAA":
+                passes = contrast_data.get("normal_aaa")
+            else:
+                passes = contrast_data.get("normal_aa")
+
+        # only add results if failure
+        if not passes:
+            if el.is_large:
+                size = "Large"
+            else:
+                size = "Normal"
+            selector = el.background_color.get("selector")
+            if not selector:
+                selector = el.color.get("selector")
+
+            # if there still isn't a selector, get the parent selector
+            if not selector:
+                selector = parent_sel
+
+            # and only if the element has direct text (experimental)
+            if el.has_direct_text:
+                results.append((filename, selector, size, rating))
 
         if not children:
             return
         else:
             for kid in children:
-                check_element(kid, rating, filename)
+                if el.background_color.get("selector"):
+                    parent_selector = el.background_color.get("selector")
+                else:
+                    parent_selector = el.color.get("selector")
+                if not parent_selector:
+                    parent_selector = kid.ancestors[-1][3]
+                    if not parent_selector:
+                        parent_selector = kid.ancestors[-1][-1]
+                    if parent_selector:
+                        parent_selector = parent_selector.split("selector:")[
+                            -1
+                        ]
+                check_element(kid, rating, filename, parent_selector)
 
     for element in elements:
         check_element(element, rating, filename)
     if results:
         adjusted = []
         for result in results:
-            adjusted.append(f"fail: ({filename}) " + result)
+            count = results.count(result)
+            file, selector, size, rating = result
+            msg = f"fail: in {file}, selector: {selector} triggered "
+            if count > 1:
+                msg += f"{count} contrast errors for {size} {rating}."
+            else:
+                msg += f"contrast error for {size} {rating}."
+            if msg not in adjusted:
+                adjusted.append(msg)
         results = adjusted
     else:
         # It's a success! Let's let them know
@@ -1716,8 +1851,6 @@ def get_color_contrast_report(dir_path: str, rating="AAA") -> list:
         for item in report:
             if item not in results:
                 results.append(item)
-        # Do one more pass on hyperlinks and double check contrast
-        print(results)
     return results
 
 

{webcode_tk-1.1.3 → webcode_tk-1.1.5}/webcode_tk/color_tools.py

@@ -808,10 +808,12 @@ def get_color_contrast_with_gradients(
             bg_color,
         ]
     composite_color = ""
+
     # check all permutations of color combinations for contrast results
     for foreground in foreground_colors:
         for background in bg_colors:
             composite_color = ""
+
             # check for background alpha transparency
             bg_has_alpha = has_alpha_channel(background)
             if bg_has_alpha:
@@ -819,11 +821,17 @@ def get_color_contrast_with_gradients(
                 for i in range(len(ancestors) - 1, -1, -1):
                     ancestor = ancestors[i]
                     if len(ancestor) > 2:
-                        base_color = ancestor[2]
-                        composite_color = blend_alpha(base_color, background)
-                        container_bg = ancestor[2]
+                        if ancestor[2]:
+                            base_color = ancestor[2]
+                            composite_color = blend_alpha(
+                                base_color, background
+                            )
+                            container_bg = ancestor[2]
+                        elif "background:" in ancestor[-1]:
+                            input("Get something in here")
                 if not composite_color:
                     composite_color = blend_alpha(container_bg, background)
+
             # convert each to hex
             hex1 = to_hex(foreground)
             if composite_color:

{webcode_tk-1.1.3 → webcode_tk-1.1.5}/webcode_tk/css_tools.py

@@ -7,6 +7,7 @@ from typing import Union
 
 from file_clerk import clerk
 
+from webcode_tk import cascade_tools
 from webcode_tk import color_keywords as keyword
 from webcode_tk import color_tools
 from webcode_tk import html_tools
@@ -2469,6 +2470,8 @@ def get_heading_color_report(project_dir: str) -> list:
         report: a list of files and a pass or fail message for each."""
     report = []
     header_re = regex_patterns.get("header_selector")
+
+    # make sure we have a trailing slash separator
     if project_dir[-1] != "/":
         project_dir += "/"
     all_file_data = get_all_project_stylesheets(project_dir)
@@ -2477,13 +2480,12 @@ def get_heading_color_report(project_dir: str) -> list:
         filepath = project_dir + filename
         all_color_rules = get_all_color_rules(filepath)
         header_selectors = []
-        for key, val in all_color_rules.items():
-            if key == "file":
-                continue
-            is_header_selector = re.findall(header_re, key)
+
+        # Look through all selectors and their values
+        # if selector is a header selector, then check color
+        for sel, val in all_color_rules.items():
+            is_header_selector = re.findall(header_re, sel)
             if is_header_selector:
-                # we have a header selector
-                # we only need to check color
                 color_data = val
                 color_value = color_data.get("color")
                 bg_value = color_data.get("background-color")
@@ -2537,7 +2539,90 @@ def get_project_color_contrast_report(project_dir: str, level="AAA") -> list:
     return report
 
 
+def get_element_rulesets(project_dir: str, element: str) -> list:
+    rulesets = []
+    styles_by_files = get_styles_by_html_files(project_dir)
+    for file in styles_by_files:
+        elements = None
+        filepath = file.get("file")
+        filename = clerk.get_file_name(filepath)
+        sheets = file.get("stylesheets")
+        elements = html_tools.get_elements(element, filepath)
+        for sheet in sheets:
+            for ruleset in sheet.rulesets:
+                sel = ruleset.selector
+                selector_applies = cascade_tools.does_selector_apply(
+                    elements[0], sel
+                )
+                if selector_applies:
+                    rulesets.append((filename, ruleset))
+
+    return rulesets
+
+
+def get_properties_applied_report(project_dir: str, goals: dict) -> list:
+    """returns a report on any elements that fail to have a property applied
+
+    Args:
+        project_dir: the path to the project folder
+        goals: a dictionary of elements and the properties expected to be
+            present
+
+    Returns:
+        report: a list of pass or fail messages that indicates the file, the
+            element, and the missing property.
+    """
+    report = []
+    elements = list(goals.keys())
+    for element in elements:
+        properties_found = []
+        properties = goals.get(element)
+        element_rulesets = get_element_rulesets(project_dir, element)
+
+        # check all rulesets for a given file to see which rulesets have
+        # one or more properties we are checking for
+        for file, rulesets in element_rulesets:
+            found_properties_remaining = list(properties)
+            for expected_property in properties:
+                declarations = rulesets.declaration_block.declarations
+
+                # check all declarations to see if any properties
+                # are a match and pull it from the list of remaining
+                # properties.
+                for declaration in declarations:
+                    element_property = declaration.property
+                    if expected_property == element_property:
+                        properties_found.append(element_property)
+                        found_properties_remaining.remove(element_property)
+                        break
+
+            # If there are any properties left, it's a fail
+            if found_properties_remaining:
+                count = len(found_properties_remaining)
+                msg = f"fail: in {file}, the {element} tag does not apply "
+                if count == 1:
+                    msg += f"1 property: {found_properties_remaining[0]}."
+                else:
+                    msg += f"{count} properties: "
+                    msg += f"{found_properties_remaining}."
+
+            # all properties were accounted for (none remaining)
+            else:
+                msg = f"pass: in {file}, the {element} tag applies all "
+                msg += "required properties."
+            report.append(msg)
+    return report
+
+
 if __name__ == "__main__":
+    project_folder = "tests/test_files/cascade_complexities"
+    goals = {
+        "figure": ("margin", "padding", "border", "float"),
+    }
+    report = get_properties_applied_report(project_folder, goals)
+    rulesets = get_element_rulesets(
+        "tests/test_files/cascade_complexities", "figure"
+    )
     insane_gradient = """
     -moz-radial-gradient(0% 200%, ellipse cover,
     rgba(143, 193, 242, 0.22) 10%,rgba(240, 205, 247,0) 40%),

{webcode_tk-1.1.3 → webcode_tk-1.1.5}/webcode_tk/font_tools.py

@@ -22,9 +22,10 @@ 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
 
-from webcode_tk.css_tools import Stylesheet
+from webcode_tk import css_tools
 
 absolute_keyword_regex = (
     r"\b(?:xx-small|x-small|small(?!-caps)|medium|large|x-large|"
@@ -76,7 +77,7 @@ FONT_NON_SIZE_NON_FAMILY_KEYWORDS = (
 )
 
 
-def get_absolute_keyword_values(css_code: Union[str, Stylesheet]) -> list:
+def get_absolute_keyword_values(css_code: any) -> list:
     """returns a list of all keyword values in CSS
 
     To be safe, we should remove all selectors using the curly brackets
@@ -85,7 +86,7 @@ def get_absolute_keyword_values(css_code: Union[str, Stylesheet]) -> list:
     Args:
         css_code: the CSS styles in either string or Stylesheet format
     """
-    if isinstance(css_code, Stylesheet):
+    if isinstance(css_code, css_tools.Stylesheet):
         styles = css_code.text
     else:
         styles = css_code
@@ -108,7 +109,7 @@ def get_absolute_keyword_values(css_code: Union[str, Stylesheet]) -> list:
     return values
 
 
-def get_numeric_fontsize_values(css_code: Union[str, Stylesheet]) -> list:
+def get_numeric_fontsize_values(css_code: Any) -> list:
     """returns a list of all numeric font size values.
 
     This should work for any standard size value (em, px, %,
@@ -117,10 +118,10 @@ def get_numeric_fontsize_values(css_code: Union[str, Stylesheet]) -> list:
     Args:
         css_code: the CSS styles in either string or Stylesheet format.
     """
-    if isinstance(css_code, Stylesheet):
-        code = css_code.text
-    else:
+    if isinstance(css_code, str):
         code = css_code
+    else:
+        code = css_code.text
     matches = re.findall(numeric_value_regex, code)
     full_matches = []
     for match in matches: