148 lines
4.1 KiB
Python
148 lines
4.1 KiB
Python
from random import choices
|
|
from string import ascii_lowercase
|
|
from typing import Any, Callable
|
|
|
|
from django.template.loader import render_to_string
|
|
from django.urls import NoReverseMatch, reverse
|
|
from django.utils.safestring import mark_safe
|
|
|
|
|
|
def Popover(
|
|
wrapped_content: str,
|
|
popover_content: str = "",
|
|
) -> str:
|
|
id = randomid()
|
|
if popover_content == "":
|
|
popover_content = wrapped_content
|
|
content = f"<span data-popover-target={id}>{wrapped_content}</span>"
|
|
result = mark_safe(
|
|
str(content)
|
|
+ render_to_string(
|
|
"cotton/popover.html",
|
|
{
|
|
"id": id,
|
|
"slot": popover_content,
|
|
},
|
|
)
|
|
)
|
|
return result
|
|
|
|
|
|
HTMLAttribute = tuple[str, str]
|
|
HTMLTag = str
|
|
|
|
|
|
def Component(
|
|
attributes: list[HTMLAttribute] = [],
|
|
children: list[HTMLTag] | HTMLTag = [],
|
|
template: str = "",
|
|
tag_name: str = "",
|
|
) -> HTMLTag:
|
|
if not tag_name and not template:
|
|
raise ValueError("One of template or tag_name is required.")
|
|
if isinstance(children, str):
|
|
children = [children]
|
|
childrenBlob = "\n".join(children)
|
|
attributesList = [f'{name} = "{value}"' for name, value in attributes]
|
|
attributesBlob = " ".join(attributesList)
|
|
tag: str = ""
|
|
if tag_name != "":
|
|
tag = f"<a {attributesBlob}>{childrenBlob}</a>"
|
|
elif template != "":
|
|
tag = render_to_string(
|
|
template,
|
|
{name: value for name, value in attributes} | {"slot": "\n".join(children)},
|
|
)
|
|
return mark_safe(tag)
|
|
|
|
|
|
def A(
|
|
attributes: list[HTMLAttribute] = [],
|
|
children: list[HTMLTag] | HTMLTag = [],
|
|
url: str | Callable[..., Any] = "",
|
|
):
|
|
"""
|
|
Returns the HTML tag "a".
|
|
"url" can either be:
|
|
- URL (string)
|
|
- path name passed to reverse() (string)
|
|
- function
|
|
"""
|
|
additional_attributes = []
|
|
if url:
|
|
if type(url) is str:
|
|
try:
|
|
url_result = reverse(url)
|
|
except NoReverseMatch:
|
|
url_result = url
|
|
elif callable(url):
|
|
url_result = url()
|
|
else:
|
|
raise TypeError("'url' is neither str nor function.")
|
|
additional_attributes = [("href", url_result)]
|
|
return Component(
|
|
tag_name="a", attributes=attributes + additional_attributes, children=children
|
|
)
|
|
|
|
|
|
def Button(
|
|
attributes: list[HTMLAttribute] = [],
|
|
children: list[HTMLTag] | HTMLTag = [],
|
|
):
|
|
return Component(
|
|
template="cotton/button.html", attributes=attributes, children=children
|
|
)
|
|
|
|
|
|
def safe_division(numerator: int | float, denominator: int | float) -> int | float:
|
|
"""
|
|
Divides without triggering division by zero exception.
|
|
Returns 0 if denominator is 0.
|
|
"""
|
|
try:
|
|
return numerator / denominator
|
|
except ZeroDivisionError:
|
|
return 0
|
|
|
|
|
|
def safe_getattr(obj: object, attr_chain: str, default: Any | None = None) -> object:
|
|
"""
|
|
Safely get the nested attribute from an object.
|
|
|
|
Parameters:
|
|
obj (object): The object from which to retrieve the attribute.
|
|
attr_chain (str): The chain of attributes, separated by dots.
|
|
default: The default value to return if any attribute in the chain does not exist.
|
|
|
|
Returns:
|
|
The value of the nested attribute if it exists, otherwise the default value.
|
|
"""
|
|
attrs = attr_chain.split(".")
|
|
for attr in attrs:
|
|
try:
|
|
obj = getattr(obj, attr)
|
|
except AttributeError:
|
|
return default
|
|
return obj
|
|
|
|
|
|
def truncate(input_string: str, length: int = 30, ellipsis: str = "…") -> str:
|
|
return (
|
|
(f"{input_string[:length-len(ellipsis)]}{ellipsis}")
|
|
if len(input_string) > 30
|
|
else input_string
|
|
)
|
|
|
|
|
|
def truncate_with_popover(input_string: str) -> str:
|
|
if (truncated := truncate(input_string)) != input_string:
|
|
print(f"Not the same after: {truncated=}")
|
|
return Popover(wrapped_content=truncated, popover_content=input_string)
|
|
else:
|
|
print("Strings are the same!")
|
|
return input_string
|
|
|
|
|
|
def randomid(seed: str = "", length: int = 10) -> str:
|
|
return seed + "".join(choices(ascii_lowercase, k=length))
|