webcode-tk 1.0.0__tar.gz → 1.0.2__tar.gz

{webcode_tk-1.0.0 → webcode_tk-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webcode-tk
-Version: 1.0.0
+Version: 1.0.2
 Summary: 
 Home-page: https://github.com/HundredVisionsGuy/webcode-tk
 License: MIT
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: MechanicalSoup (>=1.1.0,<2.0.0)
 Requires-Dist: bs4 (>=0.0.1,<0.0.2)
 Requires-Dist: file-clerk (>=1.0.9,<2.0.0)

{webcode_tk-1.0.0 → webcode_tk-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "webcode-tk"
-version = "1.0.0"
+version = "1.0.2"
 description = ""
 authors = ["hundredvisionsguy <cwinikka@gmail.com>"]
 keywords = ["html", "validation", "css", ]

{webcode_tk-1.0.0 → webcode_tk-1.0.2}/webcode_tk/__init__.py

@@ -18,4 +18,4 @@ Modules exported by this package:
 - `validator_tools`: sends HTML or CSS code to the W3C Validator to check
           for errors.
 """
-__version__ = "1.0.0"
+__version__ = "1.0.2"

{webcode_tk-1.0.0 → webcode_tk-1.0.2}/webcode_tk/cascade_tools.py

@@ -1493,7 +1493,7 @@ def update_contrast_results(
 
 
 def get_color_contrast_details(tree: CSSAppliedTree, rating="AAA") -> list:
-    """returns a list of all all failures or a pass based on rating
+    """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
@@ -1567,7 +1567,12 @@ def get_color_contrast_details(tree: CSSAppliedTree, rating="AAA") -> list:
 
     for element in elements:
         check_element(element, rating, filename)
-    if not results:
+    if results:
+        adjusted = []
+        for result in results:
+            adjusted.append("fail: " + result)
+        results = adjusted
+    else:
         # It's a success! Let's let them know
         msg = f"success: {filename} passes color contrast for {rating} Normal"
         msg += " and Large."

{webcode_tk-1.0.0 → webcode_tk-1.0.2}/webcode_tk/css_tools.py

@@ -2222,6 +2222,245 @@ def is_link_selector(selector: str) -> bool:
     return bool(selector_match)
 
 
+def get_all_project_stylesheets(project_dir: str) -> list:
+    """returns a list of all styles and stylesheets from a project folder.
+
+    This includes styles from style tags as well as linked stylesheets.
+
+    Args:
+        project_dir: the relative link to the folder with the web docs.
+
+    Returns:
+        all_files_styles: a list of all stylesheets and style tag contents.
+    """
+    directory = project_dir
+    html_files = clerk.get_all_files_of_type(directory, "html")
+    all_files_styles = []
+    for file in html_files:
+        filename = clerk.get_file_name(file)
+        stylesheets = get_all_stylesheets_by_file(file)
+        all_files_styles.append((filename, stylesheets))
+    return all_files_styles
+
+
+def no_style_attributes_allowed_report(project_dir: str) -> list:
+    """returns a report on whether HTML docs use style attributes or not.
+
+    Only call this report if you do not allow a style attribute in an
+    HTML doc
+
+    Args:
+        project_dir: the relative link to the folder with the web docs.
+
+    Returns:
+        report: a list of all HTML docs and a pass or fail message.
+    """
+    report = []
+
+    html_files = clerk.get_all_files_of_type(project_dir, "html")
+    for file in html_files:
+        try:
+            has_style_attr = html_tools.has_style_attribute_data(file)
+        except AttributeError:
+            continue
+        if has_style_attr:
+            result = f"fail: {file} uses style attributes"
+        else:
+            result = f"pass: {file} does not use style attributes"
+        report.append(result)
+    return report
+
+
+def styles_applied_report(project_dir: str) -> list:
+    """returns a report of all files in a project folder that apply styles
+
+    This lets us know for each HTML doc if they apply styles (pass) or
+    if they do not apply styles (fail)
+
+    Args:
+        project_dir: a relative path to the project folder.
+
+    Returns:
+        report: a list of HTML docs and whether they pass or fail (pass) means
+            they did apply styles and fail is the opposite.
+    """
+    report = []
+    html_files = clerk.get_all_files_of_type(project_dir, "html")
+    for file in html_files:
+        styles = get_all_stylesheets_by_file(file)
+        if not styles:
+            results = f"fail: {file} does NOT apply CSS."
+        else:
+            results = f"pass: {file} applies CSS."
+        report.append(results)
+    return report
+
+
+def fonts_applied_report(project_dir: str, min=1, max=2) -> list:
+    """returns a report of all files in a project folder that apply font
+    families.
+
+    You can set the minimum and maximum number of fonts applied per page.
+
+    Args:
+        project_dir: the relative path to the project folder we want to check.
+        min: the minimum number of fonts applied per file.
+        max: the maximum number of fonts applied per file.
+    Returns:
+        report: a list of font data results.
+    """
+    report = []
+    all_file_data = get_styles_by_html_files(project_dir)
+    for file in all_file_data:
+        number_of_fonts = 0
+        filename = clerk.get_file_name(file.get("file"))
+        stylesheets = file.get("stylesheets")
+        font_styles = []
+        for sheet in stylesheets:
+            font_details = get_font_families(sheet)
+            number_of_fonts += len(font_details)
+            for item in font_details:
+                selector = item.get("selector")
+                family = item.get("family")
+                if "," in family:
+                    first_font = family.split(",")[0].strip()
+                else:
+                    first_font = family
+                first_font = first_font.replace("'", "")
+                first_font = first_font.replace('"', "")
+                if first_font.lower() == "times new roman":
+                    results = f"fail: {filename}: {selector} element was set "
+                    results += "to the default font"
+                elif number_of_fonts >= min and number_of_fonts <= max:
+                    results = f"pass: {filename}: {selector} element "
+                    results += f"was set to {first_font}"
+                elif number_of_fonts < min:
+                    results = f"fail: {filename} did not apply {min} fonts, "
+                    results += f"instead, it applied {number_of_fonts} fonts."
+                if results not in font_styles:
+                    font_styles.append(results)
+        # We have all font styles applied
+        if not font_styles:
+            report.append(f"fail: {filename} No modified fonts for {filename}")
+        else:
+            report += font_styles
+    if not report:
+        report.append("fail: no html files to apply font styling to")
+    return report
+
+
+def get_global_color_report(project_dir: str, level="aaa") -> list:
+    """Returns a report on which files in a project apply global colors
+
+    Args:
+        project_dir: the project folder path.
+        level: whether we are testing for Normal AAA or Normal AA
+
+    Returns:
+        report: a list of files and a pass or fail message for each."""
+    report = []
+    all_file_data = get_all_project_stylesheets(project_dir)
+    for data in all_file_data:
+        filename = data[0]
+        passes = []
+        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)
+                    passes.append(f"pass: {file} {result}")
+        if passes:
+            details = ""
+            for detail in passes:
+                details += detail
+        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")
+    return report
+
+
+def get_color_data(file: str, color_details: dict, level="aaa") -> tuple:
+    """returns the color contrast data on a color.
+
+    pulls out the selector, background color, text color, contrast
+    ratio, and whether it passes color contrast.
+
+    Args:
+        file: just the name of the file (not path).
+        color_details: tuple of full color & bg color details.
+        level: the level of normal text (AAA or AA).
+
+    Returns:
+        color_data: a tuple with filename and results as a string"""
+    selector = color_details.get("selector")
+    bg_color = color_details.get("background-color")
+    color = color_details.get("color")
+    contrast_ratio = color_details.get("contrast_ratio")
+    if level == "aaa":
+        passes = color_details.get("passes_normal_aaa")
+    else:
+        passes = color_details.get("passes_normal_aa")
+    if passes:
+        results = "passes global colors"
+    else:
+        results = f"{selector} {bg_color} and {color} fail with a contrast"
+        results += f" ratio of {contrast_ratio}."
+    color_data = (file, results)
+    return color_data
+
+
+def get_heading_color_report(project_dir: str) -> list:
+    """Returns a report on which files in a project apply heading colors
+
+    For now, we just want to have at least a color or background color
+    applied.
+
+    Args:
+        project_dir: the project folder path.
+
+    Returns:
+        report: a list of files and a pass or fail message for each."""
+    report = []
+    header_re = regex_patterns.get("header_selector")
+    if project_dir[-1] != "/":
+        project_dir += "/"
+    all_file_data = get_all_project_stylesheets(project_dir)
+    for file in all_file_data:
+        filename = file[0]
+        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)
+            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")
+                if color_value:
+                    if bg_value:
+                        header_selectors.append(
+                            (filename, color_value, bg_value)
+                        )
+                    else:
+                        header_selectors.append((filename, color_value, None))
+                if bg_value:
+                    header_selectors.append((filename, None, bg_value))
+        if header_selectors:
+            report.append(f"pass: {filename} applies colors to headers")
+        else:
+            report.append(f"fail: {filename} does NOT apply colors to headers")
+    if not report:
+        report.append("fail: no html files to apply header colors to")
+    return report
+
+
 if __name__ == "__main__":
     insane_gradient = """
     -moz-radial-gradient(0% 200%, ellipse cover,

{webcode_tk-1.0.0 → webcode_tk-1.0.2}/webcode_tk/html_tools.py

@@ -410,6 +410,30 @@ def add_if_not_in(my_list: list, item: str) -> None:
         my_list.append(item)
 
 
+def get_number_of_elements_per_file(
+    project_dir: str, element_data: list
+) -> list:
+    """returns a list of number of elements per file in a project folder.
+
+    Args:
+        project_dir: the folder we want to check
+        element_data: a list of tuples of element (str) and required number
+        (int)
+
+    Returns:
+        elements_per_file: a list of tuples that includes the file, the
+            element, and the number of occurrences.
+    """
+    elements_per_file = []
+    all_html_files = get_all_html_files(project_dir)
+    for file in all_html_files:
+        for i in range(len(element_data)):
+            # Get requirements for exact number
+            element, number = element_data[i]
+            elements_per_file.append((file, element, number))
+    return elements_per_file
+
+
 if __name__ == "__main__":
     file_with_inline_styles = "tests/test_files/sample_with_inline_styles.html"
     markup = clerk.file_to_string(file_with_inline_styles)

{webcode_tk-1.0.0 → webcode_tk-1.0.2}/webcode_tk/validator_tools.py

@@ -7,6 +7,8 @@ import requests
 from bs4 import BeautifulSoup
 from file_clerk import clerk
 
+from webcode_tk import html_tools as html
+
 w3cURL = "https://validator.w3.org/nu/?out=json"
 
 # Instantiate a stateful browser
@@ -89,7 +91,7 @@ def get_markup_validity(file_path: str) -> list:
         errors: a list of dictionary types (converted from the JSON
             response from the validator."""
     errors = []
-    payload = open(file_path)
+    # payload = open(file_path)
     with open(file_path, "rb") as payload:
         headers = {
             "content-type": "text/html; charset=utf-8",
@@ -253,6 +255,61 @@ def validate_css(css_code: str) -> bs4.ResultSet:
     return results
 
 
+def get_project_validation(project_dir: str, type="html") -> list:
+    """returns a report on HTML or CSS validation per HTML file.
+
+    You choose the project folder and the type (html or css), and it
+    will return a list of per-files errors
+    """
+    report = []
+    passing_files = []
+    all_files = clerk.get_all_project_files(project_dir)
+    for file in all_files:
+        errors = []
+        file_type = clerk.get_file_type(file)
+        filename = clerk.get_file_name(file)
+        if type == "html" and file_type == "html":
+            errors = get_markup_validity(file)
+            if errors:
+                report.append(
+                    f"fail: {filename} has {len(errors)} validation errors."
+                )
+            else:
+                passing_files.append(filename)
+        else:
+            if file_type == "html" and type == "css":
+                style_tag = html.get_elements("style", file)
+                if style_tag:
+                    code = html.get_element_content(style_tag)
+                    result = validate_css(code)
+                    errors_list = get_css_errors_list(result)
+                    if errors_list:
+                        errors += errors_list
+                    else:
+                        passing_files.append(filename)
+            if file_type == "css":
+                code = clerk.file_to_string(file)
+                result = validate_css(code)
+                errors_list = get_css_errors_list(result)
+                if errors_list:
+                    errors += errors_list
+                else:
+                    passing_files.append(filename)
+            if errors:
+                report.append(
+                    f"fail: {filename} has {len(errors)} css errors."
+                )
+    if not report:
+        if passing_files:
+            for passing_file in passing_files:
+                msg = f"pass: {passing_file} passes {type.upper()} validation"
+                report.append(msg)
+        if not passing_files:
+            report.append("fail: no files present to validate")
+    # TODO - make sure this covers all scenarios
+    return report
+
+
 if __name__ == "__main__":
     path = "tests/test_files/sample_with_errors.html"
     report = get_markup_validity(path)