Create Table of all Bootstrap Classes

from IPython.display import display, HTML, Javascript
from chamelboots import ChameleonTemplate as CT
from chamelboots import TalStatement as TS
from chamelboots.constants import Join

ATTRIB_CONTENTS = ATTRIBUTES, STRUCTURE_CONTENT = (
    TS("attributes", "attrib"),
    TS("content", "structure content"),
)
SEARCH_FORM = "searchForm"
TOP = "top"

HTML(
    Join.LINES(
        (
            CT("h1", ATTRIB_CONTENTS).render(
                attrib={"class": "display-4"},
                content=CT(
                    "a", (ATTRIBUTES,), inner_content="Jump to Search Form"
                ).render(attrib=dict(href=f"#{SEARCH_FORM}", id=TOP)),
            ),
            CT("h1", ATTRIB_CONTENTS).render(
                attrib={"class": "display-4"},
                content=CT(
                    "a", (ATTRIBUTES,), inner_content="Jump to Functioning Search Form in HTML"
                ).render(attrib=dict(href=f"link://slug/searchable-table-of-bootstrap-classes")),
            ),
        )
    )
)

import urllib.request
import urllib.parse
from urllib.error import HTTPError
from enum import Enum
import itertools as it
from string import punctuation

from chamelboots.constants import global_safe, WhiteSpace, Join
from lxml import etree
import pandas as pd

from bs4 import BeautifulSoup

URL = "https://bootstrapcreative.com/resources/bootstrap-4-css-classes-index/"
with urllib.request.urlopen(URL) as fh:
    HTML_STRING = etree.parse(fh, etree.HTMLParser())

doc = HTML_STRING.getroot()

tbody, _, _ = (e for e in doc.iter() if e.tag == "tbody")

data_ = (
    [
        str(cell.text).strip() or (cell.find("a") and cell.find("a"))
        for cell in row.iterchildren()
    ]
    for row in tbody.iterchildren()
    if row.tag == "tr"
)
data = [
    [
        cell.text.strip() if (not isinstance(cell, str) and cell is not None) else cell
        for cell in row
    ]
    for row in data_
]


class PPEnum(Enum):
    def __str__(self):
        return self.value


COLUMNS = ["class_name", "description", "category"]
Columns = PPEnum(
    "Colums", type=str, names=zip((item.upper() for item in COLUMNS), COLUMNS)
)
if global_safe(Columns.__members__):
    globals().update(Columns.__members__)

df = (
    pd.DataFrame([rows[:1] + rows[2:] for rows in data], columns=Columns)
    .sort_values(by=CATEGORY, axis=0)
    .reset_index(drop=True)
)

bootstrap_url = "https://getbootstrap.com/docs/4.3/components/forms/"
tokens_ = urllib.parse.urlsplit(bootstrap_url)
tokens_
PREFIX_TOKENS = tokens_[:2]
SUFFIX_TOKENS = tokens_[3:]
PREFIX_TOKENS, SUFFIX_TOKENS

def verify_url(request):
    # Open the URL url, which can be either a string or a Request object.
    try:
        with urllib.request.urlopen(request) as fh:
            fh.getcode()
            return request.get_full_url()
    except HTTPError:
        return None

translation = str.maketrans(dict(zip(punctuation, it.cycle(("",)))))
CLASS_WORDS = {item.split('-')[0].translate(translation).title() for item in df[CLASS_NAME]}
list(CLASS_WORDS)[0:10]

categories_ = set(df[CATEGORY])
categories = [
    *categories_,
    *[item.strip("s") for item in categories_],
    *CLASS_WORDS,
]

UTILIT = "Utilit"
COMPONENTS = "components"
PATHPREFIX = "/docs/4.3/"
UTILITIES = "utilities"
PATH_PARTS = (UTILITIES, COMPONENTS)
[category for category in categories if UTILIT in category]

def transform(category):
    return "-".join(category.lower().split(" "))

def get_valid_urls(path_part):
    return sorted(
        {
            (category, result)
            for category in categories
            if (
                result := verify_url(# verify with function and capture with the walrus.
                    urllib.request.Request( # create a request object
                        urllib.parse.urlunsplit( # create a URL
                            (
                                *PREFIX_TOKENS,
                                f"{PATHPREFIX}{path_part}/{transform(category)}/",
                                *SUFFIX_TOKENS,
                            )
                        ),
                        method="HEAD",
                        headers={"User-Agent": "Mozilla/5.0"},
                    )
                )
            )
            is not None
        }
    )

valid_urls = list(
    it.chain.from_iterable(get_valid_urls(path_part) for path_part in PATH_PARTS)
)

[item for item in valid_urls if UTILITIES in item[-1]]

display(HTML(df.head().to_html()))

valid_urls

series = pd.Series([None for _ in range(len(df))])

for category, url in valid_urls:
    for i, item in enumerate(df.itertuples()):
        lower_category = category.lower()
        if any(
            (
                lower_category in item.category.lower(),
                lower_category in item.class_name.lower(),
            )
        ):
            # print(i, url, item.category)
            series[i] = CT(
                "a", (TS("attributes", "attrib"),), inner_content="bootstrap docs"
            ).render(attrib=dict(href=url, target="_blank"))
df["URLs"] = series

ID = "query"
query_form = Join.LINES(
    [
        CT(
            "form", (TS("attributes", "attrib"), TS("content", "structure content"),)
        ).render(
            attrib={"method": "GET", "action": "#", "id": SEARCH_FORM},
            content=CT(
                "div", (TS("attributes", "attrib"), TS("content", "structure content"),)
            ).render(
                attrib={"class": "form-group",},
                content=Join.LINES(
                    [
                        CT(
                            "label",
                            (TS("attributes", "attrib"),),
                            inner_content="Bootstrap Classes Search: Search the table for text.",
                        ).render(
                            attrib={
                                "class": "col-sm-2 col-form-label col-form-label-lg",
                                "for": ID,
                            }
                        ),
                        CT("input", (TS("attributes", "attrib"),),).render(
                            attrib={
                                "type": "text",
                                "class": "form-control",
                                "id": ID,
                                "placeholder": "Enter search term",
                            }
                        ),
                        CT(
                            "button",
                            (TS("attributes", "attrib"),),
                            inner_content="search",
                        ).render(attrib={"type": "submit", "class": "btn btn-primary"}),
                        CT(
                            "button",
                            (TS("attributes", "attrib"),),
                            inner_content="clear",
                        ).render(
                            attrib={"type": "button", "class": "btn btn-secondary"}
                        ),
                    ]
                ),
            ),
        ),
    ]
)

print(BeautifulSoup(query_form, "html.parser").prettify())

table_html = df.to_html(escape=False)

for item in query_form, table_html:
    display(HTML(item))

js_code = """function filterTable(table, needle){
    var needle_ = needle.toLowerCase(),
        rows = Array.from(table.rows),
        results = rows
        .slice(1)
        .filter(row => !Array.from(row.cells)
                .some(cell => cell.textContent.toLowerCase().includes(needle_)))
    results.forEach((row)  => $(row).hide())
}

function resetTable(table){
    Array.from(table.rows).forEach(row => $(row).show())
}

var rows = document.getElementsByTagName('table'),
    [_, table, __] = rows; // second table
if(table){
    resetTable(table);
}
$('.btn-secondary').on('click', function(event){
    event.preventDefault();
    $('input').val("");
    resetTable(table);
    
})
$('#searchForm').on('submit', function(event){
    event.preventDefault();
    if(table){
       resetTable(table);
       filterTable(table, $('input').first().val())
    }
})"""

Javascript(js_code)

from pathlib import Path
import os

from chameleon import PageTemplateFile

parent = Path(os.pardir)
pages_dir = parent.joinpath('pages')

page, = pages_dir.iterdir()
template = parent.joinpath('table_template.html')
print(template.read_text())

page.write_text(PageTemplateFile(template).render(items=(query_form, table_html,)))