Skip to content

helpers

remove_none_values 

remove_none_values(d: T) -> T

Remove all keys with a None value from a dict.

Source code in client/src/jobq/utils/helpers.py 
11
12
13
14
def remove_none_values(d: T) -> T:
    """Remove all keys with a ``None`` value from a dict."""
    filtered_dict = {k: v for k, v in d.items() if v is not None}
    return cast(T, filtered_dict)

snake_to_human 

snake_to_human(s: str) -> str

Convert a snake_case string to a human-readable string.

Source code in client/src/jobq/utils/helpers.py 
17
18
19
def snake_to_human(s: str) -> str:
    """Convert a snake_case string to a human-readable string."""
    return s.replace("_", " ")

camel_to_human 

camel_to_human(s: str) -> str

Convert a camelCase string to a human-readable string.

Examples:

>>> camel_to_human("camelCase")
'Camel Case'
>>> camel_to_human("camelCaseString")
'Camel Case String'
>>> camel_to_human("randomID")
'Random ID'
Source code in client/src/jobq/utils/helpers.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def camel_to_human(s: str) -> str:
    """Convert a camelCase string to a human-readable string.

    Examples
    --------
    >>> camel_to_human("camelCase")
    'Camel Case'
    >>> camel_to_human("camelCaseString")
    'Camel Case String'
    >>> camel_to_human("randomID")
    'Random ID'
    """
    # Use regex to find positions where a lowercase letter is followed by an uppercase letter
    s = re.sub("([a-z])([A-Z])", r"\1 \2", s)

    # Capitalize the first letter of each word
    return s

to_human 

to_human(s: str) -> str

Convert a string to a human-readable string.

Source code in client/src/jobq/utils/helpers.py 
41
42
43
44
45
46
47
48
def to_human(s: str) -> str:
    """Convert a string to a human-readable string."""
    result = s
    if s.islower():
        result = snake_to_human(s)
    else:
        result = camel_to_human(s)
    return result.title()

format_dict 

format_dict(d: Mapping[str, Any], level: int = 0, indent_width: int = 2) -> str

Format a dict in a human-readable format.

Simple values are printed as-is, lists are printed as comma-separated values, and dicts are recursively formatted with keys as section headers.

Source code in client/src/jobq/utils/helpers.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
def format_dict(d: Mapping[str, Any], level: int = 0, indent_width: int = 2) -> str:
    """Format a dict in a human-readable format.

    Simple values are printed as-is, lists are printed as comma-separated values,
    and dicts are recursively formatted with keys as section headers.
    """

    def format_value(value: Any, level: int) -> str:
        if isinstance(value, Mapping):
            return format_dict(value, level + 1)
        elif isinstance(value, list):
            return "\n".join(
                " " * ((level + 1) * indent_width)
                + "- "
                + format_value(item, level + 1).strip()
                for item in value
            )
        else:
            strval = str(value).strip()
            if "\n" in strval:
                return "\n" + textwrap.indent(
                    strval, prefix=" " * (level * indent_width)
                )
            else:
                return strval

    indent = " " * (level * indent_width)
    formatted_items = []

    for key, value in d.items():
        formatted_value = format_value(value, level) or f"{indent}    <empty>"
        header = f"{indent}{to_human(key)}"

        if isinstance(value, list | Mapping):
            formatted_items.append(f"{header}:\n{formatted_value}\n")
        else:
            formatted_items.append(f"{header}: {formatted_value}")

    return "\n".join(formatted_items)